Leaderboard

Computer Requirements: A CPU with AMD-V or Intel VT-x support (pretty much any modern CPU). 4 GB RAM (more is better). Make sure Virtualization (AMD-V or Intel VT-x) is enabled in the BIOS. To do this, you’ll need to google “enable virtualization” along with your bios or motherboard version, then follow the steps. Picking Your Hypervisor A hypervisor is software that allows you to create a virtual computer (sometimes called a Virtual Machine and abbreviated to VM) which is that is isolated from your real machine. We will use the hypervisor to create a separate Windows installation that can be infected with malware without causing harm to us or our data. I personally have used about 5 different hypervisors I frequently use because each one has subtle differences that i find makes them better for different tasks, I’ll explain what I use each for and why. VMware Workstation Pro – Very high performance and is probably the best hypervisor to run on a Windows operating system, it’s also packed full of extra features which makes it useful for complex virtual networks. VMware Workstation Player – Stripped back and lightweight version of Pro, great for simple and easy VM setup but doesn’t support snapshots which is a major problem for malware analysis. I have this installed on my laptop for on the road demos. KVM – Runs on Linux and has a cool plugin that allows you to run more VMs that your system has RAM by using memory de-duplication. KVM is great for avoid malware detecting it’s in a VM because most malware relies on the presence of VirtualBox or VMWare specific artifacts and doesn’t care much for detecting other hypervisors. ESXi – It’s not a hypervisor that you install on your operating system, the hypervisor is the operating system. By having an operating system built around the hypervisor, overhead is reduced because there’s no need for any code other than that required to run the hypervisor. VirtualBox -Allows you to spoof the hardware your VM runs on, avoiding malware figuring out that it’s in a VM by probing virtual/physical hardware or firmware version; it’s free, easy to set up, and has most of the features paid hypervisors have. For beginners I’d recommend VirtualBox because it’s free, supports most major operating systems, and has a snapshot feature allowing you to rollback the VM to a saved point. For this reason, I will base the post on VirtualBox. Picking Your Guest OS The operating system running inside the Virtual Machine is fairly important and depends on a couple of things, I’ll go into details on each. Your Skill Set If you’re planning to reverse engineer malware and you only understand x86 assembly (or are learning Assembly), then it would make sense to run an x86 Windows installation. The majority of malware runs under WoW64 (Windows’ way of running 32-bit binaries on 64-bit systems), so you’ll likely be reverse engineering 32-bit code regardless of what architecture you use. In some cases malware will drop a 32-bit or 64-bit payload depending on the architecture, so if you don’t know 64-bit assembly, you’ll want the 32-bit payload, which means using a 32-bit (x86) operating system. Your Hardware A x86_64 CPU can run 32-bit and 64-bit VMs, but a x86 CPU can only run 32-bit VMs, so if your CPU is x86 you should pick a 32-bit operating systems. Older CPUs (especially x86 ones) might not support features required by newer Windows installations, so it’d also be best to stay below Windows 8. If your computer doesn’t have much RAM, you’ll be better off running a Windows XP VM as this can run on as little as 256 MB of RAM (make sure to use Service Pack 3 though as it adds some features to the OS which most malware relies on). Windows 7 VMs generally require 1 GB of ram, but you can probably get away with 768 MB (512 MB for Home Edition). Your Experience Most malware will work on every Windows system between XP Service Pack 3 and Windows 10, so if you find you’re more familiar with XP, then don’t be afraid to use it. Windows 10 is very resource intensive and may not be supported by all malware, so for general day to day malware analysis I recommend staying away from Windows 10 unless you absolutely need it for some reason. Windows 10 is also incredibly noisy in terms of internet connected background services, which will fill up your packet capture with useless and irrelevant data. Your Malware 64-bit operating systems utilize something called DSE (Driver Signature Enforcement) which prevents loading of unsigned kernel drivers, if you’re analyzing malware which installs a kernel driver, then a 32-bit operating system is your best bet because it won’t have a problem with malware installing unsigned drivers. What do I use? I’m actually lucky enough to now have a powerful rackmount server in my basement (courtesy of my employer), so I have a VM of every OS from XP to 10 as well as both 32-bit and 64-bit installations, but previously my personal preference was Windows 7 Ultimate Edition (32-bit) for working with common malware (I use Ultimate for the Remote Desktop feature, but if you’re happy using VNC then Home Edition is fine). It’s also important to remember that the VM will be used to run and analyze malware, so not using older operating systems because they’re “insecure against hackers/malware” is counter productive when the intention is to infect it with malware. Setting Up Your Virtual Machine RAM I recommended you use the minimum amount suggested by requirements for your chosen operating system. CPU The “Processor(s)” option defines how many CPU cores the VM can use. One should be fine, but if you have a CPU with more than a single core, consider setting the limit higher to speed up the VM. Execution Cap should be left at 100% unless you set the Processor(s) setting to the same number of cores your CPU has, in which case consider lowering the limit to avoid VMs freezing your computer. Network Make sure to select the “NAT” option. It will allow your VM to connect to the internet but not see devices on your real network or talk to other VMs, which is good from a security standpoint. The rest of the options can be left as is. Although it’s not required for a simple malware analysis environment, you can harden VirtualBox to prevent malware detecting it’s in a VM by using hfireF0x’s loader. Installing Windows Windows 7, 8, and 10 ISOs can be gotten here if you have a valid product key (do not use your product key to activate Windows once installed in the VM or malware could steal your key; instead leave Windows un-activated). Windows XP doesn’t seem to be available from the Microsoft site, but I believe it’s legal to download Windows ISO torrents as long as the installers are not cracked or patched. Simply don’t activate Windows as you don’t need any of the benefits of activating when the VMs only purpose is running malware. You don’t need to mount the installer ISO to a CD, simply navigate to the “Storage” category in options, click the CD icon which says “Empty” next to it, click the second CD icon in the top right and select the install ISO. Once you boot the VM it will automatically boot from the ISO. Go through the Windows installation process like you would normally, skip the activation section, and consider changing your computer name and username to make the VM seem less like a research machine. Avoid installing “Guest Additions” as the toolset is commonly used by malware to detect that it’s running inside a VM. Environment Setup As soon as Windows is installed you should take a snapshot by clicking “Machine” > “Take Snapshot”, this will create an image of the current VM state so you can rollback later or create new VMs from the same image. A snapshot is like creating a copy of your VM’s hard disk and RAM content; when you “roll back” to a snapshot, it’s like overwriting the hard disk and RAM with the data saved during the snapshot, undoing any changes, and of course malware infections that happened after the snapshot was taken). Now it’s time to pick and install your analysis tools, fo you’re not sure what to install, here is a list of my suggestions to get started: Disassemblers / Debuggers OllyDbg WinDbg (Installed as part of the Windows SDK) x64Dbg IDA (Freeware Edition) Radare2 PE Tools PE Explorer Explorer Suite PEStudio Process Tools Process Hacker ProcMon Process Explorer Process Dump User Mode Process Dumper Network Tools Wireshark Fiddler mitmproxy Other HxD (Hex Editor) PaFish (Testing for VM detection) oledump (Extract Macros from Office Documents) olevba (VBA Macro Extractor) Strings (Extracts ASCII and Unicode Text from Files) Once you’re done installing your favorite tools, create another snapshot and you’re ready to go (when you want to install new tools, simply rollback to this snapshot, install your new tools, then create a new snapshot and delete the old one). Warnings There’s no recorded cases of malware using zero-day exploits to escape a virtual machine, you should be safe if you practice good VM hygiene. Never plug USB devices into your virtual machine, assume every file in your VM has been infected and never transfer files that are infectable outside your virtual machine, don’t log into any servers inside an infected VM. Be careful when using features such as “Shared Folders” to share folders between your computer and the VM. Anything in these folders can easily be stolen, infected, or destroyed by malware inside the VM. Don’t run malware samples you’re not familiar with on an internet connect VM. Malware can launch DDoS attacks, hack computers, and commit financial fraud from your IP address; your front door is much nicer when it hasn’t been knocked off its hinges by law enforcement. If you run a VPN inside your VM it can be disabled or bypassed by malware, exposing your real IP address. Criminals will generally not target researcher, but if you want to hide your IP address then you should run the VPN on your computer and not inside your VM. Avoid storing executable malware samples where they can be accidentally run. Either rename files to something non-execuctable (like .bin or .malware) before they touch your computer, or store them on a webserver in a non-executable directory. Anything you put inside your VM can and probably will be stolen by malware you run inside it, use common sense. Use snapshots to save your progress while doing analysis. If you’re taking notes in your VM and it crashes or gets encrypted by ransomware, your data will be lost if you haven’t backed it up. Anti-viruses will still scan and delete non-executable malware samples or even your notes if they match malicious signatures, whitelist the folder you save your research in. Sursa: https://www.malwaretech.com/2017/11/creating-a-simple-free-malware-analysis-environment.html

Daca te numesti Madalin, incearca parola la iCloud “madalinsugepula”. Daca merge dai de baut.

DNA-ul isi cumpara all inclusive de la cellebrite http://www.grupul.ro/wp-content/uploads/2017/10/Caiet_sarcini_IT_softuri_DNA.pdf

Striker is an offensive information and vulnerability scanner Features Just supply a domain name to Striker and it will automatically do the following for you: Check and Bypass Cloudflare Retrieve Server and Powered by Headers Fingerprint the operating system of Web Server Detect CMS (197+ CMSs are supported) Launch WPScan if target is using Wordpress Retrieve robots.txt Check if the target is a honeypot Port Scan with banner grabbing Dumps all kind of DNS records Generate a map for visualizing the attack surface Gather Emails related to the target Find websites hosted on the same web server Find hosts using google Crawl the website for URLs having parameters SQLi scan using online implemention of SQLMap (takes < 3 min.) Basic XSS scanning Screenshots Want to see what else it can do? Try it yourself. Contriubute If you want to contribute to this project, report any bugs you encounter and help me add more features to it. Download: Striker-master.zip or git clone https://github.com/UltimateHackers/Striker.git Sources: https://github.com/UltimateHackers/Striker https://teamultimate.in

I can actually look up how long I have by logging into my Coinbase account, looking at the history of the Bitcoin wallet, and seeing this transaction I got back in 2012 after signing up for Coinbase. Bitcoin was trading at about $6.50 per. If I still had that 0.1 BTC, that’d be worth over $500 at the time of this writing. In case people are wondering, I ended up selling that when a Bitcoin was worth $2000. So I only made $200 out of it rather than the $550 now. Should have held on. Thank you Brian. Despite knowing about Bitcoin’s existence, I never got much involved. I saw the rises and falls of the $/BTC ratio. I’ve seen people talk about how much of the future it is, and seen a few articles about how pointless BTC is. I never had an opinion on that, only somewhat followed along. Similarly, I have barely followed blockchains themselves. Recently, my dad has brought up multiple times how the CNBC and Bloomberg stations he watches in the mornings bring up blockchains often, and he doesn’t know what it means at all. And then suddenly, I figured I should try to learn about the blockchain more than the top level information I had. I started by doing a lot of “research”, which means I would search all around the internet trying to find other articles explaining the blockchain. Some were good, some were bad, some were dense, some were super upper level. Reading only goes so far, and if there’s one thing I know, it’s that reading to learn doesn’t get you even close to the knowledge you get from programming to learn. So I figured I should go through and try to write my own basic local blockchain. A big thing to mention here is that there are differences in a basic blockchain like I’m describing here and a ‘professional’ blockchain. This chain will not create a crypto currency. Blockchains do not require producing coins that can be traded and exchanged for physical money. Blockchains are used to store and verify information. Coins help incentive nodes to participate in validation but don’t need to exist. The reason I’m writing this post is 1) so people reading this can learn more about blockchains themselves, and 2) so I can try to learn more by explaining the code and not just writing it. In this post, I’ll show the way I want to store the blockchain data and generate an initial block, how a node can sync up with the local blockchain data, how to display the blockchain (which will be used in the future to sync with other nodes), and then how to go through and mine and create valid new blocks. For this first post, there are no other nodes. There are no wallets, no peers, no important data. Information on those will come later. Other Posts in This Series Part 2 — Syncing Chains From Different Nodes Part 3 — Nodes that Mine TL;DR If you don’t want to get into specifics and read the code, or if you came across this post while searching for an article that describes blockchains understandably, I’ll attempt to write a summary about how a blockchains work. At a super high level, a blockchain is a database where everyone participating in the blockchain is able to store, view, confirm, and never delete the data. On a somewhat lower level, the data in these blocks can be anything as long as that specific blockchain allows it. For example, the data in the Bitcoin blockchain is only transactions of Bitcoins between accounts. The Ethereum blockchain allows similar transactions of Ether’s, but also transactions that are used to run code. Slightly more downward, before a block is created and linked into the blockchain, it is validated by a majority of people working on the blockchain, referred to as nodes. The true blockchain is the chain containing the greatest number of blocks that is correctly verified by the majority of the nodes. That means if a node attempts to change the data in a previous block, the newer blocks will not be valid and nodes will not trust the data from the incorrect block. Don’t worry if this is all confusing. It took me a while to figure that out myself and a much longer time to be able to write this in a way that my sister (who has no background in anything blockchain) understands. If you want to look at the code, check out the part 1 branch on Github. Anyone with questions, comments, corrections, or praise (if you feel like being super nice!), get in contact, or let me know on twitter. Step 1 — Classes and Files Step 1 for me is to write a class that handles the blocks when a node is running. I’ll call this class Block. Frankly, there isn’t much to do with this class. In the __init__ function, we’re going to trust that all the required information is provided in a dictionary. If I were writing a production blockchain, this wouldn’t be smart, but it’s fine for the example where I’m the only one writing all the code. I also want to write a method that spits out the important block information into a dict, and then have a nicer way to show block information if I print a block to the terminal. class Block(object): def __init__(self, dictionary): ''' We're looking for index, timestamp, data, prev_hash, nonce ''' for k, v in dictionary.items(): setattr(self, k, v) if not hasattr(self, 'hash'): #in creating the first block, needs to be removed in future self.hash = self.create_self_hash() def __dict__(self): info = {} info['index'] = str(self.index) info['timestamp'] = str(self.timestamp) info['prev_hash'] = str(self.prev_hash) info['hash'] = str(self.hash) info['data'] = str(self.data) return info def __str__(self): return "Block<prev_hash: %s,hash: %s>" % (self.prev_hash, self.hash) When we’re looking to create a first block, we can run the simple code. def create_first_block(): # index zero and arbitrary previous hash block_data = {} block_data['index'] = 0 block_data['timestamp'] = date.datetime.now() block_data['data'] = 'First block data' block_data['prev_hash'] = None block = Block(block_data) return block Nice. The final question of this section is where to store the data in the file system. We want this so we don’t lose our local block data if we turn off the node. In an attempt to somewhat copy the Etherium Mist folder scheme, I’m going to name the folder with the data ‘chaindata’. Each block will be allowed its own file for now where it’s named based on its index. We need to make sure that the filename begins with plenty of leading zeros so the blocks are in numerical order. With the code above, this is what I need to create the first block. #check if chaindata folder exists. chaindata_dir = 'chaindata' if not os.path.exists(chaindata_dir): #make chaindata dir os.mkdir(chaindata_dir) #check if dir is empty from just creation, or empty before if os.listdir(chaindata_dir) == []: #create first block first_block = create_first_block() first_block.self_save() Step 2 — Syncing the blockchain, locally When you start a node, before you’re able to start mining, interpreting the data, or send / create new data for the chain, you need to sync the node. Since there are no other nodes, I’m only talking about reading the blocks from the local files. In the future, reading from files will be part of syncing, but also talking to peers to gather the blocks that were generated while you weren’t running your own node. def sync(): node_blocks = [] #We're assuming that the folder and at least initial block exists chaindata_dir = 'chaindata' if os.path.exists(chaindata_dir): for filename in os.listdir(chaindata_dir): if filename.endswith('.json'): #.DS_Store sometimes screws things up filepath = '%s/%s' % (chaindata_dir, filename) with open(filepath, 'r') as block_file: block_info = json.load(block_file) block_object = Block(block_info) #since we can init a Block object with just a dict node_blocks.append(block_object) return node_blocks Nice and simple, for now. Reading strings from a folder and loading them into data structures doesn’t require super complicated code. For now this works. But in future posts when I write the ability for different nodes to communicate, this sync function is going to get a lot more complicated. Step 3 — Displaying the blockchain Now that we have the blockchain in memory, I want to start being able to show the chain in a browser. Two reasons for doing this now. First is to validate in a browser that things have changed. And then also I’ll want to use the browser in the future to view and act on the blockchain. Like sending transactions or managing wallets. I use Flask here since it’s impressively easy to start, and also since I’m in control. Here’s the code to show the blockchain json. I’ll ignore the import requirements to save space here. node = Flask(__name__) node_blocks = sync.sync() #inital blocks that are synced @node.route('/blockchain.json', methods=['GET']) def blockchain(): ''' Shoots back the blockchain, which in our case, is a json list of hashes with the block information which is: index timestamp data hash prev_hash ''' node_blocks = sync.sync() #regrab the nodes if they've changed # Convert our blocks into dictionaries # so we can send them as json objects later python_blocks = [] for block in node_blocks: python_blocks.append(block.__dict__()) json_blocks = json.dumps(python_blocks) return json_blocks if __name__ == '__main__': node.run() Run this code, visit localhost:3000/blockchain.json, and you’ll see the current blocks spit out. Part 4 — “Mining”, also known as block creation We only have that one genesis block, and if we have more data we want to store and distribute, we need a way to include that into a new block. The question is how to create a new block while linking back to a previous one. In the Bitcoin whitepaper, Satoshi describes it as the following. Note that ‘timestamp server’ is referred to as a ‘node’: The solution we propose begins with a timestamp server. A timestamp server works by taking a hash of a block of items to be timestamped and widely publishing the hash... The timestamp proves that the data must have existed at the time, obviously, in order to get into the hash. Each timestamp includes the previous timestamp in its hash, forming a chain, with each additional timestamp reinforcing the ones before it. Here’s a screenshot of the picture below the description. A summary of that section is that in order to link the blocks together, we create a hash of the information of a new block that includes the time of block creation, the hash of the previous block, and the information in the block. I’ll refer to this group of information as the block’s ‘header’. In this way, we’re able to verify a block’s truthfulness by running through all the hashes before a block and validating the sequence. For my header the case here the header I’m creating is adding the string values together into a giant string. The data I’m including is: Index, meaning which number of block this will be Previous block’s hash the data, in this case is just random strings. For bitcoin, this is referred to as the Merkle root, which is info about the transactions The timestamp of when we’re mining the block def generate_header(index, prev_hash, data, timestamp): return str(index) + prev_hash + data + str(timestamp) Before getting confused, adding the strings of information together isn’t required to create a header. The requirement is that everyone knows how to generate a block’s header, and within the header is the previous block’s hash. This is so everyone can confirm the correct hash for the new block, and validate the link between the two blocks. The Bitcoin header is much more complex than combining strings. It uses hashes of data, times, and deals with how the bytes are stored in computer memory. But for now, adding strings suffices. Once we have the header, we want to go through and calculate the validated hash, and by calculating the hash. In my hash calculation, I’m going to be doing something slightly different than Bitcoin’s method, but I’m still running the block header through the sha256 function. def calculate_hash(index, prev_hash, data, timestamp, nonce): header_string = generate_header(index, prev_hash, data, timestamp, nonce) sha = hashlib.sha256() sha.update(header_string) return sha.hexdigest() Finally, to mine the block we use the functions above to get a hash for the new block, store the hash in the new block, and then save that block to the chaindata directory. node_blocks = sync.sync() def mine(last_block): index = int(last_block.index) + 1 timestamp = date.datetime.now() data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions prev_hash = last_block.hash block_hash = calculate_hash(index, prev_hash, data, timestamp) block_data = {} block_data['index'] = int(last_block.index) + 1 block_data['timestamp'] = date.datetime.now() block_data['data'] = "I block #%s" % last_block.index block_data['prev_hash'] = last_block.hash block_data['hash'] = block_hash return Block(block_data) def save_block(block): chaindata_dir = 'chaindata' filename = '%s/%s.json' % (chaindata_dir, block.index) with open(filename, 'w') as block_file: print new_block.__dict__() json.dump(block.__dict__(), block_file) if __name__ == '__main__': last_block = node_blocks[-1] new_block = mine(last_block) save_block(new_block) Tada! Though with this type of block creation, whoever has the fastest CPU is able to create a chain that’s the longest which other nodes would conceive as true. We need some way to slow down block creation and confirm each other before moving towards the next block. Part 5 — Proof-of-Work In order to do the slowdown, I’m throwing in Proof-of-Work as Bitcoin does. Proof-of-Stake is another way you’ll see blockchains use to get consensus, but for this I’ll go with work. The way to do this is to adjust the requirement that a block’s hash has certain properties. Like bitcoin, I’m going to make sure that the hash begins with a certain number of zeros before you can move on to the next one. The way to do this is to throw on one more piece of information into the header — a nonce. def generate_header(index, prev_hash, data, timestamp, nonce): return str(index) + prev_hash + data + str(timestamp) + str(nonce) Now the mining function is adjusted to create the hash, but if the block’s hash doesn’t lead with enough zeros, we increment the nonce value, create the new header, calculate the new hash and check to see if that leads with enough zeros. NUM_ZEROS = 4 def mine(last_block): index = int(last_block.index) + 1 timestamp = date.datetime.now() data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions prev_hash = last_block.hash nonce = 0 block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce) while str(block_hash[0:NUM_ZEROS]) != '0' * NUM_ZEROS: nonce += 1 block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce) block_data = {} block_data['index'] = int(last_block.index) + 1 block_data['timestamp'] = date.datetime.now() block_data['data'] = "I block #%s" % last_block.index block_data['prev_hash'] = last_block.hash block_data['hash'] = block_hash block_data['nonce'] = nonce return Block(block_data) Excellent. This new block contains the valid nonce value so other nodes can validate the hash. We can generate, save, and distribute this new block to the rest. Summary And that’s it! For now. There are tons of questions and features for this blockchain that I haven’t included. For example, how do other nodes become involved? How would nodes transfer data that they want included in a block? How do we store the information in the block other than just a giant string Is there a better type of header that doesn’t include that giant data string? There will be more parts of the series coming where I’ll move forward with solving these questions. So if you have suggestions of what parts you want to see, let me know on twitter, comment on this post, or get in contact! Thanks to my sister Sara for reading through this for edits, and asking questions about blockchains so I had to rewrite to clarify. Sursa: https://bigishdata.com/2017/10/17/write-your-own-blockchain-part-1-creating-storing-syncing-displaying-mining-and-proving-work/ part 2: https://bigishdata.com/2017/10/27/build-your-own-blockchain-part-2-syncing-chains-from-different-nodes/ part 3: https://bigishdata.com/2017/11/02/build-your-own-blockchain-part-3-writing-nodes-that-mine/

Nokia 6650 Classic, no sarcasm around edit: folosesc pla

https://www.ebay.co.uk/itm/Nokia-5110-5130-Black-Unlocked-Mobile-Phone/222013254804

yotaphone 3 este un telefon nu foarte performant dar interesant (are display secundar e-ink)

Un X jailbreakuit, a man can just dream

Tu momentan esti la nivelul de script kid. Nu e asa de rau, ca esti destul copil, si eu cand eram de 13 ani dadeam deface la nicublog.freedomain.tk . 1 Totusi fii constient ca: risti sa iti bagi curul la probleme cu defaceul. Sunt sysadmini care te ard nu conteaza cat de pusti esti. Te sfatuiesc sa o lasi mai moale cu defaceul. Sa mai rascolesti printr-un site/db mai merge dar defaceurile iti pot aduce probleme. 2 Esti totusi destul de maricel si ar trebui sa evoluezi rapid pe plan moral. Gandeste-te si la viitorul tau si la ce vrei sa faci (daca vrei) cu secititatea/programarea. E bine sa te apuci de invatat chestii mai serioase cat mai repede daca vrei sa ajungi departe. Ca sa faci asta cat mai bine incearca sa te indepartezi de "scripuri", "havij","tutoriale cum sa spargi". Citese carti despre securitate, citeste articole universitare, citeste despre kracks si SQL si Dirty COW. Urmeaza tutorialele si prezentarile lui @Nytro /Defcamp/Defcon si incearca sa le intelegi, sa inveti tot ce contin ele. Aici e esenta "securitatii" nu in defaceuri.

Ooo da, imediat se activeaza dna'ul in cazul unuia inselat de nevasta

Salut tuturor. Incerc sa accesez Icloud-ul fostei sotii(online de la PC),avand doar userul de Icloud(fara password) si acces la adresa de e-mail(deplin) .Exista vreo metoda de a reseta parola prin e-mail,fara a introduce numarul de telefon ?(Nu am acces la telefonul ei sa pot citi codul primit prin mesaj) .