Split (1)

train · 180k rows

instruction stringlengths 24 29.9k
I've been trying out a few desktop email clients (Windows) to better manage my e-mail. As I tried Thunderbird, Inky, and Outlook, it occurred to me, what guarantee is there that my e-mail/pass won't be compromised by using email clients? Wouldn't it be really simple for the author(s) of e-mail clients to incorporate a function that sends the users' login info to a predefined server? I just wanted to know whether I'm being paranoid or is this a valid concern?
I've been warned that PHP's $_SERVER['HTTP_REFERER'] is a common attack vector for websites. What are ways that attackers exploit this function? How can I guard against them?
I store my passwords in an encrypted database file in the cloud. That is, my KDBX files from KeePass are stored in a cloud storage server, let's say it's Dropbox. Dropbox, whether they admit it or not, probably keeps a very long history of my files. If someone were to attempt to decrypt my KDBX file, would it help them if they had successive copies of my KDBX file over time? I sometimes update just one line in the file and re-sync to Dropbox. Are these files engineered in such a way (i.e. without some sort of random seed) that would give someone great advantage in decrypting the file if they studied successive copies of the file?
Is it unwise to use gmail to discuss business ideas that Google could snoop on and use to their business advantage? I know that email is not secure and anyone could read it along its path of delivery, but I feel the level of potential snooping is much higher with gmail and google than regular email. So under the gmail Terms of Service (TOS) is Google allowed to read your emails and make business decisions based upon learning what you write about or may they only use the information to target advertising toward you? If not allowed under their TOS, is it wise to avoid free email services like gmail anyway since they are looking already and thus could easily violate the TOS with little effort. In summary, if I'm going to discuss business ideas with another individual over email, is there any real benefit to using a service other than gmail, such as a paid service where the provider does not have the right to look through your emails?
I am presently working as a summer intern. My first objective is, given a collection of files, recover and identify the file types present in it. To download sample pseudo-forensics data I have been using: Digital Corpora To recover files I have been using 'The Sleuthkit' but this does not seem to do the work as I always get error messages regarding the format of the data being used. It would be great to get suggestions/links to tutorials or software which help in recovering data. I am also looking forward to links to download psuedo forensic data similar to the one above. Specifically, I would like to recover all data that are in text formats(word,pdf,emails,html... etc) then unify it into one single file in text format and then use natural language processing to determine places the person was associated with. I have some ideas with respect the natural language processing aspect of the problem but need help with respect to data recovery. How best to do this task.
I am an undergraduate Computer Science student and was hoping to gain some knowledge of ways to help prevent Denial Of Service attacks.I read about some of here: https://en.wikipedia.org/wiki/SYN_cookies https://en.wikipedia.org/wiki/Port_knocking But was having difficulty as to how to start to convert them to practical terms as simulation will require attacks too on the same system.Besides,these attacks become more deadlier if IP is spoofed. Any solutions for that and how can I simulate them.
Is it possible to exploit a vulnerable application that is running inside a process virtual machine? Let's say that we have buffer overflow vulnerability in a Java application but the JVM isn't vulnerable. Is there a way to exploit it?
At IEEE Security & Privacy, the blind return-oriented programming attack (blind ROP) was just introduced. In some sense, this is just another variation on ROP attacks -- but the blind ROP attack is notable because it does not require any knowledge of the source code or the binary of the program you are attacking; you can attack "blind". Also, their attack is entirely automated, so it is very easy for attackers to use, and it defeats ASLR and DEP. Thus, this seems like a new kind of threat that might become attractive to attackers and is worth defending against. How should we defend against blind ROP? What are the best available defenses that we can deploy today? How can/should we harden our servers and applications against blind ROP attacks? References: Hacking Blind, Andrea Bittau, Adam Belay, Ali Mashtizadeh, David Mazieres, Dan Boneh, IEEE Security & Privacy 2014.
I have the need for a company laptop (Dell e6540) that contains our java application on it to go out for evaluation purposes. For this reason I would like to make sure that the HDD is protected from customers (or anyone else) being able to take our java app off of the laptop and view the source. We have taken many necessary precautions and hardened the OS putting it into a custom "kiosk-like" mode. My last obstacle is to get the key for disk encryption stored on the TPM of the Dell Laptop. This way I can have an encrypted disk without giving a customer the password/key. This has proven to be a nightmare so far under Ubuntu 12. All of the documents I find are at least 4-5 years old. The interaction of using LUKS with TPM-LUKS and Trousers is unstable on the newer linux versions (at best) The requirements are Disk Encryption (either partition or FDE) without having to give the password to the users. Is anyone aware of a solution on Linux? This is seamless on Windows using BitLocker. I have offered up SecureDoc as a solution but they do not see their product as a good fit.
I'm working on the authentication strategy for my app (again). My current strategy is a clone of the AWS strategy of issuing public and private keys and using them to sign requests sent to my API. My understanding is that this is a reasonably secure way to authenticate API consumers. However, AWS is phasing out this practice, and I don't really know why. Is there something I don't know about Private/Public key authentication that poses a security risk to my service or its users? Is it safe to continue this practice, or should I bite the bullet and move to OAUTH or some other strategy? The context for the sake of this question is that this strategy is used to authenticate consumers of my JSON-RPC API. Client-side, the private key is used to hash various data contained within the JSON object; server-side the same key is retrieved to compare a hash of the data received with the signature. Thanks for any help.
I have to go through background check. The company providing the service to the client is called Verifications, Inc. Verifications, Inc claims to have a data security plan, ISO certification and US Federal clients. I was surprised to learn the company provides a web based system and sends the username and password via plain text email to external systems. For example, the company will send invitation emails to an AOL or Mindspring account. I know emailing the password violates NIST practices. For example, it violates SP800-53's Authenticator Management IA-5 and possibly IA-6. It also violates handling practices of SP800-118. Does anyone know if emailing a plain text password is acceptable practice under any ISO? Does data sensitivity affect handling under the ISO?
Would just like some input on a PHP script I'm writing. It's just a simple script that only myself should be able to access. I don't have a dynamic IP address, so this isn't an issue for me, but I'm wondering if there's any potential problems in my "security" measure. Currently my script is setup like this: $uip = $_SERVER['REMOTE_ADDR']; if ($uip == "my personal ip here") { echo "access granted"; } else { echo "access denied"; } Is this "safe"? Or is it easy for somebody that knows my IP to be able to spoof their visit to the PHP script using my IP and trick the script into thinking it's my IP? Any suggestions? I don't want to over-complicate things (in example a login page) and just want to know if my KISS solution is viable or potentially problematic.
What are the vulnerabilities mitigated by a tiered LAMP stack? As I understand it, any breach would allow access to the database even if it was tiered. What's the benefit? Are we better to concentrate on WAFs?
If I create a private key via: openssl req -x509 -newkey rsa:2048 -out cert.crt then OpenSSL writes the private key to the file privkey.pem and if you do not provide the -nodes parameter it will encrypt the private key. Which default encryption is used? A private key generated with this command: cat privkey.pem : -----BEGIN ENCRYPTED PRIVATE KEY----- MIIFDjBABgkqhkiG9w0BBQ0wMzAbBgkqhkiG9w0BBQwwDgQIo1rE/z2PcrMCAggA MBQGCCqGSIb3DQMHBAiDRNWrVvL7CQSCBMgkkOxb7ovb6T0xPjl40T64qNeMhYav lqXpBLdZZGAnu6Y+Cl4yhr9/Aqnt6wWWf8Dlbdd/cRxenZ1Y+bAhiXWTVNxqMX9I Qjk2pIpjSkIVSM3tt47XGX+7qIEQxGBaM9yq8U8FjkvkvlVFvJhhbMZQLB0wxheC +P/YA2co74u51DZr2YKf8Oo/ZVpQ3ivv2Nv7HCDMsymQKylFtOWWup20jAUMrcVx VAu+Nn95XYa9yBXGMxMw/52p9/FZMcgtCG5EdITP/xerVh0Qrl+aZWYs9n6yl25K pQ7eboewA8hDHg0CrOsImm4KquB1bhHQTL8Ns5xvq7c43PEUi6CTu4/5bNlkgg71 /y9zzJH1K3xvqS2rb7tjOYLyDMvJkHguNL0WG/SxetArppdrA3wwuBeSogCEFbKE dXoQwTPf56uMbVXjHIHCJKnn6oRNDBAUgYvd3ifsiZX0MF1Tll64iqLgUilAItoa wASWsudJCb0HhXR73hmtPC+BQECtsXfRYmCg/ffKtZZIqXRplECWDQR8F0kcsvj1 rZQDffFKGiv9ftW6bS51a0xa1WGpIgtcNeLtz0JBGkZwN3ykQCGDkk2khBGFYxfu Xkm2G6cuwVMDg8ekg0ie95Zj2nCjS2TtnpKFiX+kxjPmfgTFzdd9jdVyA3ZEpfC/ HZRwEfoaXDgiUP6nOBEB00VLXkjoTw7oFheP8LkX9yJkGokXeSstyl3YXyFvTbNs vk1oa4qyTmTAaWWIpkYDFc/8p6wtQpYLqkz8eyKiNDsZIxpo5upyya1U3dEuX1Pu XCoHDsR6t+OINW2CCtMh2VhG5FRMK0sRPDGfOof32/HbIRE/mJf+cyxdk12aXrbu 3kiKxM72LJiEmcP2Yzw9Wbgnen5zBZlLEcLopHqVdWZS1QNKvpGHl+drUAGmGGIZ fB4evfS2YLmZrhP01nAqNwRHntJXlyoOWKsJz9F6RAA87tGRhAuKX9R7j6vMFrU8 83RL3JAqnt1AvSOSkd8NMJb041aSKvlRcGC1Gzw/kebzQTy5m4PZDiNrgnRGtucO KPwyMA43HnObY4apD5H8VQrgREp+o1Rnjnvx3+l8o7SuGXf7CqMT6B2kpYgECSP5 9f3YNLkxGZFAoD5G4QPQRHLJmoFsiZ25bYVjleCHIR05WkktV6ps9Hk5qyQocmaU Agf4opOJfV3KoL3czcnNLdXzG+O6q1n9W+9OCI7ku+Z/v+K8sQkUaH0qjc8w3tV/ Bjq+6kvyk70V9rftbu0yu2gBXqjTdtCE4jhM4pdAGpC2iQr0pKGMRYaSDqNbXtZX bRreZTxxk8mI+mEjpIyA8jrm0E6jdBd2M0SLI4VCUdkINyk1zRZp+A2zZMUhMp5V jC2syFs2Od19Ax7WVj+bkDsRSF0TKdpp8/hC9zEzz+oztrhHOG3+sfJJznjm4ZtW Wm2Wwa5PVQxNVIXT5kX6/HNBdgRdc09bYAo5KPXgeNNgd7Jpz1GinEIR4y8mZa8s DXkBlXfew+jzHA7eqRSWdwVHvlj9an6snSuBeKjNYKew9zRTX1ANFpq4Pa9mV+LI /ckYfEoHD3wLWohzNs42dNvtj4DWeqlIHiu5dEpLMjxKeMvqMFxP/SZufE3VCMN+ sMY= -----END ENCRYPTED PRIVATE KEY----- If you generate an RSA private key with: openssl genrsa -out privkey2.pem 2048 then it is not encrypted by default. If you add -aes256 (or anything else supported) the output will be: cat privkey2.pem -----BEGIN RSA PRIVATE KEY----- Proc-Type: 4,ENCRYPTED DEK-Info: AES-256-CBC,D02DE734A8C2DBA625FC4180E7AECC78 T6KNkW3KdCoIaAoLqBaDZIqFbG9o8Zk+xy+N10GKJTSS51kW1At7zV0JWbnpSpsR X/M/ntawXqntZdffX+YQSc3wkd7cAislnclfnRPuoXjHl8VVN3cw1nDV7En2RrwD 4V2zwcnMtzct6chKE+fitOB+br0+G073Rd3IcBWRnu978zHu+geKUnzC4HIylrhq mbsAQBpPpq1GS0Si/hKRG3MZl4tCAtfdWUC8xTKJ/JKb7IC/wGb3FmegMRAkahXn NqbyoFG0UmM25KGSYNJQl+iEVubF1T66HTBstN1Eccmq5Cas1FGWCtLE1+RiYziL ve+ZXPjxy+a0zsnA1FKRLpAb/TH2U4PdBQpznfw1ULszAiO/9oX7lU/ImjvmT8Zd ko3OKb4wlaEN3/I3aD/RQq1rJwXY09+235PNSj/W7MUZ67N14/K/Q+6mVYykj+I7 VhEt54xa39kHpO5UWbEitnNYlmJmTs+tzJZkSzxjCPTYMzYX+CSJvYZ7Qa5Fazq4 XDXyYL7qbTaaxBloj1TKSbnGDxfW4aTLgDg63zNBQyz/jRPBsQE9KdtFr2Tndkvr efbiz+gKHFsdl0xnZJax/AtTgL1DFwID/zMrrPXRy60mHMRf4s8Uab9X5aqflqch iIQA55b+pZuhvNPWsW39H7xQDrYeLACaP0c8cHrsDTALh9ebQrrIfC7iutU5Nih8 1E4xLz0/6H4VtLXx78cYTkFTlb4Quar5W2MxzIZK27Rn5XvWWoHc0tLZQVVzyGfj +/ZRbBv+VPkHwhNUHH+dyeiA6dmY/B/hsbftjx3tAt0DsEoMTYUZ0eY24kOb1FGg WZpws2PQEOOCU/Wpflbf4o8Go1NY/1UjKOieqS1bphzFO9CthdBEmlx6nnW+X2jc JgXkhh7dWp6Z/ziSmfXaCfKIhCwmxUbL5OFgRZIaTSIl2BNGunBFoLIAJHl1YPMy Fyr29bj9yvvMFwFgiGfJ6euDKh8J28FFacKAptEnIDJITKX9lnTTlJnSC7AKUN/z GlJbh+ZAnMn5nR0ghS8DS42A8nXfClfKiRO277e7sf/RWq/ktBrjS65bDvhiz7nl QuF+BJiAZL6Evfj5IQA4V7xpbdt/izjIjQAeOT8UejVs9XJGu90sLlDXlnBLxowV K1gqU5kj1Uqt3kzU7omokNGM8LRaiPj6brWt3zOzWiyQb0RUGHbm7tEVQXcoAa8h SEtZRPmUgyIiLIA23uASVUcV7qL4TYlO4mL1KeaC/8ZAEjFAECQSNu6l80lChunE jbftFHV9vPZkyiM3Sfjv49PNoJ2v7NdBUTZr+ajiDIi1AW7lXmrcIBHo15a4+pHU PvMvJXO5cXwexzbuBADicXcq1PooZogs6mFlHuDDBb9avnZhVTk+yq+Ii8OTvDVi ZdFxQhxB6FbV72xdqRXvaqwujcvQRWVmUM4jUR+WQR1ZcW1jl1UjJKu+CcfmbjPG RlK10HH4CId3VqHsYUhf2JuzLcRwR4dng5Z/Ye3c0hip0QRBWyp/HzVh66ItPtB9 A2UIk2IBvMI9YPciXTWSjcZogemRH1GL0ZiE0Lgma9iPttdWSofL0yJ09lUW3bR6 -----END RSA PRIVATE KEY----- I did not find any command to get the type of encryption. The passphrase for both are: pass.
Is it possible to compare encrypted private keys if you do not have the passphrase? E.g.: openssl genrsa -out unencryptedprivkey.pem 2048 openssl rsa -in unencryptedprivkey.pem -aes128 -out aes128encprivkey.pem openssl rsa -in unencryptedprivkey.pem -aes128 -out aes128encprivkey2.pem cat aes128encprivkey2.pem !-----BEGIN RSA PRIVATE KEY----- Proc-Type: 4,ENCRYPTED DEK-Info: AES-128-CBC,0468AF97F2CA19C8C5860D1BA506B341 MwYCfvtLgYzjCnJNe0MNUKnkjnkzTRG6nQX1BbE9AQEdfEQO1FOJI7qjFNVihITB En0i2lcS7dZ7hswqHt0cPUzKU5tEyMfbDNeCl6mg9QlFeobWFczqAf3Ifq1vKwWr S4src/8POhJsvbK10bqHmlbaBK7wPcKSBvEGP8vt8FtqyE40q1uu9cxAcG4LkpF5 JZHy9svhQoPuz1bqPSTbUaLMxm2YEmdzuDyrC3IyN6dmEYzav93f07JvD7aSYgjV MJuBcVKMt8HbgAKlq9jgB2Ubwsi9RtWTd/e5SRw0x7C1ImdlXwubv724N9NBRV67 4iHgIdpDBit3+5wD400CNOBr4AItts4wpC6ydvLvGtoRrCPHRHk7JwYChT3al1yb 57MFK8chLAgPx2PdHeb6KUB4s7x6E1IJos7DIR2YljEvcCCt75tYufCiOpA1MNN5 b718bOTrmlz4Sh7DCxE4HKSyZdJdpMvEcubHVY9to1HIRUmMBpYV+Yc1q+UZMPJ5 2evRcoW9fVT2eZ33dlg5Cepo80dEbvvBuraAuAU/3AP6GLolh5C5H7VStm7YDPRZ bUAGDTfAfdDPz03xPJt7stv82YG/xFmCTn9cDX2BSUWFCvAaRMp3CIPH/FZXnWO6 uLrdJYjqRmQWTc05sBQ0OtO02I7u/N08qJVT3Qd1a/Cq1NvtnuBnCyL02xlvFpe9 HXf6twDOckCOfGGukVuTaVqAMqiuu2ueypnqX2n/oTI0YCXT+TkuGcSOgRyWt9/k IXio1pIBLw9vIixXd9R3GiMhG//krqROgO92gtW4biePzdaJhGQvQKtaNkaKQw+G x4skI4jsXK5FIllwHQ20D37XUbDcnclI/ukQ1jv9SfMgJ2sYsgvVKVoYJj9Og/cP yv80vAri1/8dIv8usMqWPS1H+V1CPzfI78HmmsHH8JgjZkUjkSrkVYtuW4Sr/ukt hemp0STKPcbdwaseszECw8J3np54fDBRnzCyeMUcHwCUYjhmg2CJcgTjyEEB14QO Egz6uE2d1+eegRf50y7W5upr9mdXxeTrkxk+migYYznN0IWaNZvJhB6qbEulBaBw vlE8/+gBI0CP1YRooUA0tFuOBfT5M3/2PGCOaaXWF+YdU7zAMnf+KRiU+jSUz1zl w3fnWKFTesEF2Sq3llCiY8PerFaR799PqBCUvTgiEZPXQiBBaUs44bkdqRK8U31y s/xFnb9kJs25tBPFU/IK28HuX4xCDK5HLPgBJCjeMsSNSqqxFE1OHC4rQnxjrbjB 0iSxGFbhLVPNTtHUDehNb7iR3NcT+t0DgDKSFuI7kv1uQaHFX6kQmA0s/AdYl2C/ L1low41t4vdXVSgCmJnKFO4Ng1L0M4ACTtnbhgvFWPUhJNR4ZtidqqwK32LDBND2 GPD3zDEGfHe9VNazDoV/htJVaCPfGXgTHzA1PjEgsLSrsR5fm54frHMv2CHdSQzn akOT8TOT5lg/IHSUH/+r2HLRL78TGzhtiWaxdyOuVdnBAPCkiMvCcrKgWg/b2r1i +q4HTUu30fw/PmeeN/+SRmkvYShaWOwH94WEfT2q1sIpWL5JZtkRm/pSqqPOY9+o -----END RSA PRIVATE KEY----- cat aes128encprivkey.pem !-----BEGIN RSA PRIVATE KEY----- Proc-Type: 4,ENCRYPTED DEK-Info: AES-128-CBC,6263DD33306AA1F9CFD84FB304FACED9 N6LFCTguNSfeISBSvciYRuMIg/OER9hy8bjwPkoUaLTBoRbvFtku9KaXwje3Mgw0 e+JFtYfjF27ZtHYbk8HFG9z0C20NiwBiFH63U3+YZBJTSKZOHmA2H+d7pT1UV9w5 xXXuf7mPEUDLwKVINF8BIez63kay+fAu6Qu2Q9V8KcjITWf/Q+bTmy+LDzOPnnyG z99GE5Ue89z5UtzlMAvASmq403FzAk9xUfj2jc6hASULGrAwKr0qYcsRx5p0Xwcm wzGLYBq3hkZ5BDhdM8wCW0pyazex7M8gX8/CJHuNcUlFt4VzjKfouIw/hPCcvWfy PJ4NrZMNDrlYuVvL4IzP8EDjvqqPqMRXmWmOzmRf3I74E+UKT9ryxiC2qgxyPThR r0Mr0ORv+vUDA4iYN12ERo7hHmCajmgLPI0Muj8HveH7mgYWO8BeM+Z/PGOaKmEE DhGFPg8YLU+74guiuCy4q4Vu8vdFCGnS9mUk+jARnIqGfv6wAoTyWHBGa0oLKz1/ xSJhgP5PkppSiekeFBHa496RG7os+usV4xWhOxP/6mupU2WW04hxUgxk/IBqzHB5 ZHm+loBbDWuY9H1ZTlUsT3xkriedYBm1nzK3VHLSuPjkcj6sMzCGlZmXKWPfBPw7 Q+zkkbapzl6RVdas35C/f1ojsrGuziOZWKimlvL2+Tde9dhjYHu3sKOIrTKLaCWe DkyX7D/zVpCCg3gur+GgG/d8Y/KiwWYV6XjIt1Y1vym/67ZItjrSdgdAadQXUpOG 0y70sHxmtaY9lxTZasQnmv9MnZX/33im3gAI2PO4SYmQv2y3ZoQAl5soE7qFWYVO wz4tJgtDW0sQDpGMnzQ7ncnuzCJzx0VbJRDUAAeTUby/m3NtArJ2XR9P21iZ929g T7uxAzO9HBfK2lmtRZQ6+Ab+sDvIJgW6to4VL3TjqfjDe1rffOQrPPGJck13P9/9 mhWmZ4pLed0+HcYtfnJ+7ofMUITKdy/e08FgYY76+eoWwkIeAM/O+1ZesDMY4VI5 DGbhs+WUwmLVwepjSu61yNgjanL8CPZIJeAiY2vx/LalzmZogoJzrDhUqp/UbYi9 wHZsP+0dQgXPkVzNNGuEeJ6a/cTAtbHCjdTL1V3OSRuD19tshoBjxezIgfjF6h7m MivovQe9SLjAvmskoo8lznr7SgQrQgZxtSL/n+90akGdYs529yRgKtmCiR4YrFNd L9dAPQyyT5R0Dky9lkGmbregRxRUFmU/nDlf30cOxs7PJ7BZyqAwYSjRzavLGE+V stzOVgI9dKplQGMev0f/vXTvFLOrmZnK0+6iUoHb9EL2PwOBiD0dD0V2MxQv7Bjj scAis5aopQgpe93E5go0/vPnfVanHgyfnI6FZSKI3A+Ty8s560cDrPNSJBZ4VxHY DQ3/XQu9N38J/JUv14KoGi1ti+Pa4Xan+iq6YW92pP3GGAJnVdVFuYdwZGLP1oPk fH1V5DxvYHn2FH9Ey4fIv7ibbNp3e4eJyT13LLsWWhNkyX1wYmZdgctuGZmlsbBB HjfXgW7Id/TFK6YsVkv2x2veVGd/xU0XtRkOsq/eS1skqLVuxxuUKpG9n1P2X1w3 -----END RSA PRIVATE KEY----- cat unencryptedprivkey.pem !-----BEGIN RSA PRIVATE KEY----- MIIEogIBAAKCAQEAxF0WL8w0fk1dlxibAZKNplzIzHx/cM+VO3D4gRahPBPB1nNW YJ+WGuVDI+U6KN10MLePMsWqDtIDsS4YxWPqqNtYd2OfT6kUBkJE9FcWwMqHkRB2 upEPhbi6RGTkKpGxn+tDLMIqizXJkTvDBWrEMsuI882EQgiWVylZ5ElbjnlfU2fs ZRVpr3FsbwI81W4lv9hm+kKe/zsdHK8zUcyaN11aZXiZDHARpzENGlSRg/19J6MD TuJR/om4IPITpvByOSG9LIUwXr8ixbo4AQ5+ejFd1ARYMD0/4HCWA2gwcz8gClJA pS7O4OG0wcQ3LCtFNDAH5oPgIqYutAcG2bny8wIDAQABAoIBAGztgnhDXD9QJYHC 6YHGzYMi51TgH0XyMUOHGKNrbUfJYfbXhmwVOwxyb3tDFq9CocjAmtQ8aGjOQbQQ 8TbWhX7kJsAb6G0lSvFp45xzjzClaOyk6Gf4PlccsV9tZFDk/1bKCDqU/0q4LLe/ IiEoJ+xRkghE0oBbCSMS0kXcF8kBOm9ZqsVE2AnI0MZvHwMn8IFPuIV8NLrLVSZO NvtT20aSf6vAqnUgaEIJD3I1WduI/QwU1GQLE0lXM8++9Q9K07TkV1xqQfuySZp1 qBiHCgNBzMxbK9nZIxh6szZNz/xPsLV8WXSSXaqVP3Dnerjpi6YDn1+aqBtcLE8M LxnUQuECgYEA/1saPId7iF4aKU+/jJgw9MzPEUgD1T7tV7EAEsIu73MPyCd8/Y3t Wx4CHAZr5ySL+yS4FgxAE1NRAdGawTelFckuBTjZ8tW2V0KzWvOjSOe0EYIzG36i KTjL7LlwxkZVW1kFo/B5vRtYDqde23I5B3vSq9sDgS/T/PTKyZJp7YMCgYEAxNvj vLP7APczkjD4lfUukzie5N2489p0xLKpXXXqOEmN3fdsRAC7stX8Ebwy/zf/PRDe PABMRUyVxhkEJ3jEJ2iQoicMMcFAzzJHMweqL6mEXEvKNUH0AQvyPAmQKu7tdw6Q 2KqRjK8zvYIw1H7NJg5kEUn3yR2eTnuGsmx52dECgYAUs40H9S/VmVNjn/x2aGwn nGb5Dq6I3iYdotLPsoBdlyVjY5glchkY9vDS1s5uma7jeFGYL/wN1QZPMG/sVBeF EZ8yey5oGl1C67xgljnZkjct6DE+fGCnGNynX00+Nbt7wVbMuJUV+J6F6ZmuDq+C 5M3qcsHw+jCkZDAAcWc3AwKBgGXfkTQnQ77VLof59brMvgSL6ZZws3TmWUUtW/40 tjfYwKTclNeANaIvoJmg9hcjaF+2qfsNAGtgXaW9bmvq0D/AmhB/+oyJALv4veXH kqfFpuyIgCUdc2NTRlERddzx9kuFaynk4xuV00W/6Psef5WxHtHfoG4geLsOq78L 6ebxAoGAPPfuY4cHq8PBYcf6++29RUM/n+aCeh+SzO8GpGo+PMaf+6Ax9pCuCZlx DDJ4uGmNcIYOr4fih4+33b2+bfmP95HP77WCYht+5Z6anzyMaliFFoyuE6Z3+FQF ubnsimYRxjDkJyYgyOebDDwwswEg2YQNVDMjTjn6F688ayv18VA= -----END RSA PRIVATE KEY----- Passphrase: pass
Is there any open source alternative to Wepawet ? I need to study techniques of JavaScript malware detection.
Some web applications enable registered users to grant temporal application access to un-registered users sending token/private/unlisted/signed URLs (I ignore the exact terminology for this), which are then used to submit sensitive/confidential user information. The reason for using such mechanism is to exempt these user from requiring an account, as they are very unfrequent to the system. This URL authentication/identification system may resemble mechanisms used to validate or reset user accounts, with the difference that they are available for a longer time span (e.g. one or two weeks). What are possible security flaws on using this mechanism to grant access to users? From my understanding, posting confidential information can be secured with SSL, however sharing these links through email is susceptible of someone intercepting the email being able to supplant the user while the link has not expired, which could result in unwanted submitted information to the server. I assume that one way to minimize risks is to enable people using the URL to POST content only, so nobody (not event the same, legitimate user) has access to any data previously submitted through the same link. So, I assuming that I am not missing anything else, is this authentication design choice justified or it is overall an unrecommended practice? Update: The alternative to this is to ask even unfrequent users to create a username/pwd. With this, you make sure that nobody makes undesired requests to your server, and in addition, you can choose to display personal information from the user anytime.
When a site gets hacked, or otherwise, the web site forces you to change your password. This is done by simply telling you to change your password, not enforcing it. Why do they do that? For instance, they could: Disable your credentials, and send you an e-mail for password reset. In case you missed the email - or you aren't using the service very often and chose to ignore the password reset email - just keep the account deactivated until sign in is attempted, then send the password reset email, with hyperlinks to report possible unauthorized sign-in tries.
I've been reading up on password storage and such, and have come to the conclusion that I need to be using bCrypt. I've got an implementation working correctly, but I'm wondering the best way to move forward with my application. The previous password storage system was simply hashing and salting. It's actually easier for me to keep this system and layer bCrypt over the top than it is to rewrite it with bCrypt alone. However, I keep reading that combining different hashing algorithms is a bad idea - so I wanted to get some clarification, as I can't think of any reason not to implement in this way: Hash(password + salt + pepper) * 1000 iterations - SHA-256 Resulting hash is run through bCrypt with its own salting and a defined work factor. Final hash stored in DB along with original salt To check password, it's rehashed as above before being put through the bScrypt hash check. Is there any reason I shouldn't be doing things this way and should abandon the original password + salt + pepper in favour of just giving the plain password to bCrypt? Thanks
It seems to me that computer software is becoming more secure every year - there are fewer zero-day exploits to be found, many hacker-proof concepts are becoming widespread (such as virtualization and strong encryption), system administrators and users are starting to become aware of the importance of security, etc. Is it reasonable to assume that the field of information security will start to shrink in a few years? Or is it just an illusion and things are getting worse?
If you run the following command on a Linux/Unix machine, among other things, you get a prompt for a password: $ ssh-keygen -t dsa Enter passphrase (empty for no passphrase): What does adding a password to your SSH key actually do? Is it more secure to use a password when prompted?
I dont understand what the problem with BigDump v0.35b. This site says that it have problem. But i dont understand it. Problem here? if (!$error && isset($_REQUEST["uploadbutton"])) { if (is_uploaded_file($_FILES["dumpfile"]["tmp_name"]) && ($_FILES["dumpfile"]["error"])==0) { $uploaded_filename=str_replace(" ","_",$_FILES["dumpfile"]["name"]); $uploaded_filename=preg_replace("/[^_A-Za-z0-9-\.]/i",'',$uploaded_filename); $uploaded_filepath=str_replace("\\","/",$upload_dir."/".$uploaded_filename); do_action('file_uploaded'); if (file_exists($uploaded_filename)) { echo ("<p class=\"error\">File $uploaded_filename already exist! Delete and upload again!</p>\n"); } else if (!preg_match("/(\.(sql\|gz\|csv))$/i",$uploaded_filename)) { echo ("<p class=\"error\">You may only upload .sql .gz or .csv files.</p>\n"); } else if (!@move_uploaded_file($_FILES["dumpfile"]["tmp_name"],$uploaded_filepath)) { echo ("<p class=\"error\">Error moving uploaded file ".$_FILES["dumpfile"]["tmp_name"]." to the $uploaded_filepath</p>\n"); echo ("<p>Check the directory permissions for $upload_dir (must be 777)!</p>\n"); } else { echo ("<p class=\"success\">Uploaded file saved as $uploaded_filename</p>\n"); } } else { echo ("<p class=\"error\">Error uploading file ".$_FILES["dumpfile"]["name"]."</p>\n"); } } With what?
I just got off the phone with Fidelity, who manage the health benefits for the company where I work. Before talking to a person, I was prompted to enter my username and password on the numeric keypad: 2 for abc, 3 for def, ... (Their passwords are limited to letters and numbers) It occurred to me that doing this severely lowers the set of possible passwords an attacker would have to run through. For example, an eight character password has only about 4^8 = 65536 possibilities once the sequence of keys is known. (Some keys map to 4 letters plus the numeral itself, so it's a bit more than that). How easy would it be for an attacker to listen to the key sequence and then brute force the password from the sequence of touch-tone digits? My guess is that phone lines are not as secure as HTTPS.
Because of the eBay hacking, I had to go and look for other accounts that I have used the same password to change the passwords on those site as well. (I know that it's very bad to have same passwords across multiple sites to begin with....but it was already done) I unfortunately don't know if I was able to find all the sites that I used that specific password. I read that once hackers get one password, they use some automated software and try the same password, with same login details on bunch of other sites/accounts. Where can I get a list of common sites that hackers try to automate login using passwords they stole? Also, do you have any tips on how I can try to find as many sites that I used the same password as possible? I already tried the ones I use a lot. Thank you in advance. Since only my name and address were potentially taken, I don't have any need for worry, right?
Why does Firefox not display the SSL logo when viewing secure sites, i.e. sites with HTTPS? It used to display at the bottom of the browser window previously but I just noticed that that bottom toolbar is not longer displayed. When I try to find the option to turn it on in Firefox, there is no such option.
Ok I am currently storing the passwords in most secure way I could think of. With use of Encryption and Hash. The passwords are first generated by user as plain-text with minimum length of 6 alpha-numeric characters up-to 24 char alpha-numeric. After the passwords plain-text value are ran against MCRYPT. Primarily the TWO_FISH cipher with random IV in ECB mode. Ones that is done the Encrypted plain-text is binded to Hash function which also add's SALT via $saltVar = dechex(mt_rand(0, 2147483647)) . dechex(mt_rand(0, 2147483647)); One's everything is in place the SALT + Encrypted password are hashed via SHA-256 and then re-hashed next 15536 rounds. Creating a relatively secure password. In my personal opinion this is sufficient way of securing the data, since in part there are no key's being used there is no way of decrypting this, other then running it again with user inputed plain-text password and creating a temporary calculated hash of the password string, after which the string can be matched to the string in the database. I would never use this for any other data, but for password I belive this is sufficient. However I would still like some profesional critisism, as to whatever my way of protecting the password plain-text is secure or not, and or maybe how I can improve what I already have if its just fine. And while I am at it, would you recomand using TWO_FISH or swapping it for SEARPENT? Thanks in advance.
I'm someone who's distant, industry-wise, from technology. I'm actually in the medical field. That said, I'm very interested in technology and specifically in information security. I'd like to make a roadmap to be a professional Pentester and may eventually switch careers (I'm 20, so that wouldn't be life changing per se), or the more probable possibility to be a professional Pentester of hospital networks and medical services (that way I can work in both jobs which is what I want). So, as I said, I need to make a syllabus for beginners to professional Pentesting as self-study material for anyone following the same path. I currently have a plan to study courses in: CompTIA's Linux+ Courses on Kali Linux CompTIA's Network+ CompTIA's Security+ EC-Council CEH Note that I don't program in any language! Would you suggest adding programming courses, and which one? And how do evaluate this study plan? Note2: This guide is not personal, it's general for ANYONE starting Pentesting. I hope it doesn't get deleted :( EDIT FOR MODS: So to narrow the scope of the question I'll add that this discussion hopes to produce a battery of opinions about the best way to approach Pentesting as a career for someone who doesn't have the ability to aquire a formal degree in the field or in Computer Science. The student/enthusiast will form his own personalized syllabus based on the opinions and experience (((which an outsider like me can't get ANYWHERE else due to not having the exposure to people in this field. I don't think there's one specific answer or one-size-fits-all model to learn any subject, and thus I think this should be open for discussion about experiences in the field and how to go about the path to learn.))) To narrow it further I personally need to be a network and web apps Pentester. My interest here in these two specialties is derived from the fact that hospital networks are proven (by a security researcher) to be extremely vulnerable. And almost all devices on that network are also vulnerable. There are also some emerging technologies in Medical Social Networks and online medical apps with sensitive patients' data, I see a market or a career for such experience in the medical information field. So to rephrase: What is a path you, experts, advise an enthusiast to pursue for a career in Network and Web Apps Pentesting?
Is there anywhere I can download a list of checksums for microsoft-published OS executable files, preferably grouped by release name? I could do the same by decompressing files on a windows setup CD, and checksumming them, and then doing the same thing to all installed updates via WSUS and some scripting, but this seems like a lot of work. There must be an easier way! Do Microsoft release such a list? As an additional, related, question - why do MS sign so few of their executables? Obviously the PE loader only verifies signatures when things are loaded in to kernel mode, but is there any reason why MS don't simply sign all executables? It'd sure make verification a lot easier.
I know that it's possible to decrypt a sniffed SSL session even when some packets were lost during the capture. I run some tests with wireshark and I saw that it's still able to decrypt part of the session. I'd like to understand better how this works. My guess is that each SSL record is encrypted separately, therefore losing a piece of a record would make the rest of the record unusable, but losing a record would not affect the decryption of following records. Of course you will end up having a hole int the reconstructed tcp segment, but at least you would be able to move on and decrypt the rest of the capture. My guess is that it's also depends by the cypher used. Any reference about this would be appreciated. Thanks
When you are connected to another computer over SSH, is all data transferred between the two computers encrypted? Or is any data sent in plaintext or any other "easy to intercept" format?
Our small comapny wants to launch a paid service, hosted on the outsourced VPS server. The obvious risk is that the machine is physically not in our office and that possibly the database could be accessed by the stuff of the host. Are there any obvious security problems with VPS that I should consider? Second question would be: How to protect DB on the VPS server so I could be sure the host will not read data there? Thank you
I want to add security to the system login. So here's my idea: If a user tries to login with a valid username but invalid password, then count it as a failed login attempt and store it in the users database for that specific user. After X failed login attempts for that user, take some specific action (eg. display captcha). However when that user is able to login successfully, reset the login attempts to in the database. Is this logic any effective?
The system for the internet and the way people can abuse it is getting worse and worse. I am having several issues with people abusing the information within my WHOIS, which if I remember is protected by international laws, or at least should be. Thanks to an email and what I was taught when it comes to doing business online: Please remember that under the terms of your registration agreement, the provision of false Whois information can be grounds for cancellation of your domain name registration. I am receiving phone calls, spam emails, and threats. I do know that my information is public, but it should not be abused because of that? Yes, I do know that I can buy the packages of private registration, but I do not exactly have $10 extra to spare in a year for my website. Is there a way to report the people who is abusing this information? Should I actually spend my money on the private registration, even though my information is being abused and most likely recorded on their computer? What is the best way to handle this abuse of my information?
I read every where that drive by download attack consists in downloading malware to the victim's PC and execute it without the victim's permission. My question: does this "download" term include downloading any given file (virus.exe, worm.js ...) ? Or does it consists only in a something like malicious JavaScript attacking vulnerable plug-ins or features of the victim's brower ? I ask this question because I did not find any article speaking about this.
As someone who usually works with people in other countries it has always been a problem to send login information to each-other. For development login details like debug databases etc sure I can send them over in clear text email or something but when it comes to actual production information such as SSH keys how do you securely send them to someone when face to face contact isn't possible.
If a narrow, trusted channel is needed (for example, there is an usb key to take data between the machines), it is okay. Although SSH will throw a big error if it tries to connect to a server pretending to be another one (RSA fingerprint wont match), it can't happen if the servers don't know eachother (also they don't know eachothers key as well). In this case - also before the first connection - a MitM attack is possible, AFAIK. The best were a command sequence on both side, which generates the needed keys on both sides.
Currently, I have two years of experience in the field of IT and IT security. The type of work isn't what I expected when I was a student. Since then, I've asked people who work in this field, who suggested me to get certified. So, I started preparing for the CompTIA Security+ certification (I need to refresh my basic knowledge), which I'd like to finish by the end of August 2014. I also want to finish the CEH V8 exam by the end of this year. Holding these certifications, I'd have a good understanding of theory and the required tools. By mid 2015, I want to obtain the much acclaimed Offensive Security Certified Professional (OSCP) certification. Am I overdoing things here? Any other suggestions by the mates of this Information Security site?
How does forensic software detect deleted files? When a file is deleted, the pointer from MFT in NTFS system is deleted and the file is no longer accessible from the OS. If our disk is fragmented how can software like Autopsy or Recuva detect where each fragment from a single file is located and how can the software order the fragments correctly to "reproduce" the file as it looked before it was deleted? I've noticed that when you delete something with CCleaner the first thing it says is "Wipe MFT free space", so my guess is that MFT works like a linked list where, when you delete a pointer the nodes still remain in the memory but are no longer accessible and this is how forensic software detect deleted files.
I've read some interesting Bluetooth vulnerability questions, but I didn't notice one recently. Bluetooth has long been disabled in our organization, and I'm looking to enabling it because of repeated help desk calls regarding peripheral support. I'm curious on the following: The sole intention is to pair Windows 7 laptops to peripherals - human interface devices (HIDs) and printers - for field workers. Are there particular vulnerabilities to be concerned about? Is there a reliable way to configure what kind of profiles can be paired, to ensure only peripherals can be used? Is limiting discoverability the most important security measure? It seems if one forces the user to activate discoverability, most vulnerabilities are mitigated. Is this true?
According to Wikipedia, the NX bit is set for all x64 binaries: OS X for Intel supports the NX bit on all CPUs supported by Apple (from 10.4.4 – the first Intel release – onwards). Mac OS X 10.4 only supported NX stack protection. In Mac OS X 10.5, all 64-bit executables have NX stack and heap; W^X protection. This includes x86-64 (Core 2 or later) and 64-bit PowerPC on the G5 Macs. However, what if the executable is is not 64 bit: Mach-O executable i386? Similarly, for ASLR, Wikipedia says that it's enabled by default for 10.7 and up: In Mac OS X Lion 10.7 (released July 2011), Apple expanded their implementation to cover all applications, stating "address space layout randomization (ASLR) has been improved for all applications. It is now available for 32-bit apps (as are heap memory protections), making 64-bit and 32-bit applications more resistant to attack." Does this mean there is no way to opt-out of it via a compiler option? If there is, how could I verify that the application has not? Are there any analogies to Windows, where some libraries may be ASLR-ed, but others not?
I am a computer science student interested in the field of security and just had a few questions. What are the pros and cons for using C# for security purposes, I had assumed applications programmed in C# would be more prone to hacking etc. than C++ due to it being a higher level language and therefore being less "powerful" however I have read up online that C++ and C are not usually recommended for security reasons as buffer overflows cause a lot of security problems. What are the "best" and "worst" programming languages to learn for security and why? Does it just come down to preference? Apologies for the vague questions, I am still a beginner, please correct me if I have made any mistakes. Thanks in advance!
After reading this article ("Everything is broken" by Quinn Norton) I was about to ask a question similar to this one (Why are security-crucial software written in unsafe languages?)... but actually I am more interested in counter-examples — where the security-crucial software is written in safe languages and does not use any "unsafe" libraries (except, maybe, some OS libraries — it's very hard to do without them...). By safe I mean, at least, not prone to buffer overflow attacks and other "nice" gifts from C/C++. I have found so far only one example — tkabber, which is written in Tcl, but it does use OpenSSL, which is written in C, which makes it inherently unsafe. And every web browser that I can think of is written in C or C++, too...
I have a php and nodejs server. User logs in on the php backend, and, when entering nodejs, the php SID cookie is being passed through a websocket. I further take the session ID, find the session file in php's directory and deserialize it, where I can access data. Is that safe? The websocket does not use a TLS connection. If not(probably) why, and what are the threats?
There is a service called ProtonMail. It encrypts email on the client side, stores encrypted message on their servers, and then the recipient decrypts it, also on the client side and the system "doesn't store keys". My question is this: How does the decryption work? I'm a bit confused. Do I have to send my decryption key to each recipient before he can read my messages?
In this article from Privacy International, it indicates that when GCHQ undertook the task of destroying sensitive data on system belonging to the Guardian newspaper, in addition to the Storage media, they destroyed certain chips within the devices, amongst others chips relating to control of the Touchpad and keyboard. So the question is, are there any known security reasons why these chips would need to be destroyed to prevent data recovery from a computing device?
We have a server that provides RESTful services to our application server. It runs on Amazon Elastic Beanstalk and mapped with a domain name and SSL certificate registered at GoDaddy. It ran perfectly fine in the last few years. In March, we renewed our SSL certificate and updated it for all the servers we have. A few days ago, we added a new resource to the RESTful service, which has a new request path, say: servername.com/rest/newResource. All of a sudden, every single web service call in our application server threw the following exception: java.net.ConnectException: General SSLEngine problem to https://servername.com/rest/newResource at com.ning.http.client.providers.netty.NettyConnectListener.operationComplete(NettyConnectListener.java:103) at org.jboss.netty.channel.DefaultChannelFuture.notifyListener(DefaultChannelFuture.java:427) at org.jboss.netty.channel.DefaultChannelFuture.notifyListeners(DefaultChannelFuture.java:413) at org.jboss.netty.channel.DefaultChannelFuture.setFailure(DefaultChannelFuture.java:380) at org.jboss.netty.handler.ssl.SslHandler.setHandshakeFailure(SslHandler.java:1429) at org.jboss.netty.handler.ssl.SslHandler.unwrap(SslHandler.java:1305) at org.jboss.netty.handler.ssl.SslHandler.decode(SslHandler.java:925) at org.jboss.netty.handler.codec.frame.FrameDecoder.callDecode(FrameDecoder.java:425) at org.jboss.netty.handler.codec.frame.FrameDecoder.messageReceived(FrameDecoder.java:310) at org.jboss.netty.channel.SimpleChannelUpstreamHandler.handleUpstream(SimpleChannelUpstreamHandler.java:70) at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:564) at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:559) at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:268) at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:255) at org.jboss.netty.channel.socket.nio.NioWorker.read(NioWorker.java:88) at org.jboss.netty.channel.socket.nio.AbstractNioWorker.process(AbstractNioWorker.java:108) at org.jboss.netty.channel.socket.nio.AbstractNioSelector.run(AbstractNioSelector.java:318) at org.jboss.netty.channel.socket.nio.AbstractNioWorker.run(AbstractNioWorker.java:89) at org.jboss.netty.channel.socket.nio.NioWorker.run(NioWorker.java:178) at org.jboss.netty.util.ThreadRenamingRunnable.run(ThreadRenamingRunnable.java:108) at org.jboss.netty.util.internal.DeadLockProofWorker$1.run(DeadLockProofWorker.java:42) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603) at java.lang.Thread.run(Thread.java:722) Caused by: javax.net.ssl.SSLHandshakeException: General SSLEngine problem Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:385) at sun.security.validator.PKIXValidator.engineValidate(PKIXValidator.java:292) at sun.security.validator.Validator.validate(Validator.java:260) at sun.security.ssl.X509TrustManagerImpl.validate(X509TrustManagerImpl.java:326) at sun.security.ssl.X509TrustManagerImpl.checkTrusted(X509TrustManagerImpl.java:283) at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(X509TrustManagerImpl.java:138) at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1325) ... 23 more Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target at sun.security.provider.certpath.SunCertPathBuilder.engineBuild(SunCertPathBuilder.java:196) at java.security.cert.CertPathBuilder.build(CertPathBuilder.java:268) at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:380) ... 29 more All the other web service calls still worked fine, except anything under this new request path. I ended up resolving this issue by importing the latest GoDaddy root certificate and our (wildcard) domain certificate to the JDK's keystore (CAcerts). Although the issue is now gone, my confusion on this topic remains. Could someone explain to me, why this was happening in the first place?
I am looking at a choice for consuming a rest service from a word document. As far as I can tell there are 2 choices. Using a .net apps as listed here: http://msdn.microsoft.com/en-us/library/office/jj229830(v=office.15).aspx where the code would be compiled. or using VBA/Macro as listed here: https://stackoverflow.com/questions/19553476/how-to-make-rest-call-with-vba-in-excel. I am aware that macros have many built in features for security and am wondering if these would out weigh the benefits of an application created and run through the apps framework.
Suppose we have a master key, and we want to encrypt some file(s). We then generate one-time key for that file, use it to encrypt file contents, and finally encrypt one-time key using master key (with IV, padding and so on). Fairly common scheme, isn't it? So, we now want to generate one-time key and store it somewhere in the encrypted file. Straightforward approach is to generate one-time key and IV and use some cipher (in my case it's AES in CBC mode) to encrypt one-time key with master key. After that we store IV and encrypted one-time key in some file. This is pretty standard way too. So in short, we go from unencrypted random value to encrypted one. But we can also move in reverse direction. We can fill some buffer with random bytes, then pretend that this buffer is serialized one-time key, decrypt one-time key back from that buffer, and use it to encrypt our file. In that case, instead of having two separate procedures for encryption and decryption of one-time keys, we can keep only decryption procedure. The question: is it okay to use that trick? Any caveats or pitfalls? Any additional constraints applied to RNG used? Basically, I just want to make sure that such a simplification won't break security.
I had turned ssh on a while ago to do some remote work. I was just looking over some netstat info when I noticed someone had established an ssh session with me D: I turned ssh off immediately and looked up the address. Netstat said the ssh session was "established". I'm assuming that means they know my password, and I'm going to change it either way, but I want to know if they definitely know my password. I assume my computer's been leaking because there were 68 packets in my Send-Q; I don't know exactly what that is, but I don't like the "Send" bit. Am I ok if I just wipe my computer and put all my data back on it? I don't do anything important, and I don't connect to any networks that might have sensitive research material or keep much banking or personal information on there. Should I "nuke it from orbit", or is that overkill? If it isn't, how would I go about doing it?
I'm working on authentication for my JSON-RPC API and my current working strategy is using signed requests sent via POST over SSL. I'm wondering if anyone can see any vulnerabilities that I haven't taken into consideration with the following signature method. All communication between the client and the server is done via POST requests sent over SSL. Insecure http requests are denied outright by the API server. Dependencies var uuid = require('node-uuid'); var crypto = require('crypto'); var moment = require('moment'); var MyAPI = require('request-json').newClient('https://api.myappdomain.com'); Vars var apiVersion = '1.0'; var publicKey = 'MY_PUBLIC_KEY_UUID'; var secretKey = 'MY_SECRET_KEY_UUID'; Request Object var request = { requestID : uuid.v4(), apiVersion : apiVersion, nonce : uuid.v4(), timestamp : moment.utc( new Date() ), params : params } Signature var signature = crypto.createHmac('sha512',secretKey).update(JSON.stringify(request)).digest('hex'); Payload Packaging (Sent as cleartext via POST over TLS) var payload = { request: request, publicKey : publicKey, signature : signature } POST Request MyAPI.post('/', payload, function(error, response, body){ console.log(result); }); Resultant Payload { "request" : { "requestID" : "687de6b4-bb02-4d2c-8d3a-adeacd2d183e", "apiVersion" : "1.0", "nonce" : "eb7e4171-9e23-408a-aa2b-cd437a78af22", "timestamp" : "2014-05-23T01:36:52.225Z", "params" : { "class" : "User" "method" : "getProfile", "data" : { "id" : "SOME_USER_ID" } } }, "publicKey" : "PUBLIC_KEY", "signature" : "7e0a06b560220c24f8eefda1fda792e428abb0057998d5925cf77563a20ec7b645dacdf96da3fc57e1918950719a7da70a042b44eb27eabc889adef95ea994d1", } Server-Side And then on the server-side the following occurs to authenticate the request: PUBLIC_KEY is used to lookup the SECRET_KEY in the DB. SECRET_KEY is used to create an HMAC of the request object from the payload. The hash sent in the payload is compared to the hash created on the server. If they match, the PUBLIC_KEY is authenticated. The timestamp is evaluated and the authentication is rejected if the request is too old, otherwise, the timestamp is authenticated. So far as I understand, this is a secure method for signing and authentication requests sent over SSL. Is this correct? Thanks in advance for any help.
Is it possible for a Mumble server operator to monitor or record users' conversations? Or are Mumble conversations encrypted end-to-end?
When I download a copy of a vulnerable program and try to exploit it by buffer overflow (any internal function calling as a payload), it works. However, when I made a same type of vulnerable program in C I am not able to exploit it and I have no idea what's going wrong. Checking on gdb I figure out that I am able to overwrite the return address on the stack but still getting a segmentation fault and my desired address is not executed. The vulnerable program: #include<stdio.h> input() { char a[4]; gets(a); puts(a); } main() { input(); printf("\nthis will execute after returning from the function\n"); } over() { printf("this can only be executed by the hacker"); } I want to execute the function over() and I used the payload printf "aaaaaaaa\xb3\x84\x04\x08" \| ./my
As I know, most hacker can crypt the virus to bypass all antivirus. Even famous antivirus like kaspersky and avast doesn't know it. So, is there a good way to find out the FUD virus and protect from it.
I need to find a XSS and propose a solution in the following code: <form action="#" method="post"> <input type="hidden" name="id" value="<?=$id?>"><br> <textarea name="body"><?=$text?></textarea><br> <input type="submit" value="Send"><br> </form><br> This is part of a message board. The submit will store the message in a database and then there is another function which reads this DB and copy the content of the register without sanitize it, so whatever I put in $text will be executed, hence vulnerable to XSS. I have added prior to that this line $text = htmlspecialchars($text);, but it's not escaping the string, so then again the script it's getting executed. Also, the $id is vulnerable as well, isn't it? How could I exploit it? Because I've been trying but no luck.
Had a chat recently with PCI compliance specialist and got to realize there is a way to steal raw data from Apache / Nginx memory e.g. credit cards. It's called "harvesting" and becomes pretty common. Let's say somebody hacked in through a file upload functionality and gained access. What would be the way to detect it if he managed to harvest anything or is still harvesting, assuming he could clean up/change logs and mods after himself?
I'm doing a study on Memory Corruption. I need to compile a list of all the exploitable memory corruption issues that have been recognized till date and provide a sample vulnerable code for it. I need help from the community. I tried searching but was unable to find any such list. Things that I have compiled Stack Overflow Heap Overflow Off by One Byte Uninitialized variable memory bug exploitation Signed/Unsigned bugs User after free Double Free ????? Please correct me if the list is wrong. I need a list of all the exploitable bugs in software written in C/C++. Thanks.
Is it possible to be recorded via our camera/micro via web browser without asking our permission ?
At the time the Cloudflare blog post “ECDSA: The digital signature algorithm of a better internet” was authored, Cloudflare was apparently one of "fewer than fifty" users of ECDSA certificates on the web. It seems they have since stopped (via ssllabs.com test). I briefly surveyed several other major web properties using that tool (Google, Yahoo, Microsoft, Facebook, Amazon, Tumblr). Only Google seems to offer an EC key and ECDSA suites. When I test locally, though (with cipherscan or openssl s_client -connect google.com:443 -cipher ECDHE-ECDSA-AES256-GCM-SHA384), I seem unable to handshake ("no peer certificate available"). Is anyone able to connect to Google (or another popular site) using an ECDSA ciphersuite?
Are there any algorithms/modes that work particularly well for shorter messages? (hundreds of bytes at most, usually < 100 bytes). I am looking at it from both security and performance point of view. I imagine padding a short message to block size isn't good for performance, and seem to recall there being crypto problems if you don't do padding a particular way. Does that mean that streaming mode would be inherently better for my scenario than a block mode?
I'm looking for a Windows utility that can list all drivers, driver-filters, services, sniffers and other information for a selected USB port. I want to check if my "USB connection" is confidential.
From the security perspective (and not usability as it's discussed here https://stackoverflow.com/questions/3648430/is-it-a-bad-idea-to-escape-html-before-inserting-into-a-database-instead-of-upon), why is it a bad idea to escape HTML before escaping SQL?
In Germany everyone is worried about a prominent political party that exposes their wp-config to the public: https://www.a*********r.de/wp-config.php How much of a security risk is that? The db, for example, is only reachable from a local ip. What information can an attacker actually use and how high is the risk? Content of the file: define('DB_NAME', 'afd-web-wp-dev'); define('DB_USER', 'afd-web-dev'); define('DB_PASSWORD', 'm****d'); //redacted for privacy define('DB_HOST', '10...'); //redacted for privacy define('AUTH_KEY', 'put your unique phrase here'); define('SECURE_AUTH_KEY', 'put your unique phrase here'); define('LOGGED_IN_KEY', 'put your unique phrase here'); define('NONCE_KEY', 'put your unique phrase here'); define('AUTH_SALT', 'put your unique phrase here'); define('SECURE_AUTH_SALT', 'put your unique phrase here'); define('LOGGED_IN_SALT', 'put your unique phrase here'); define('NONCE_SALT', 'put your unique phrase here'); $table_prefix = 'e******y_'; //redacted for privacy define('WPLANG', 'de_DE'); define('WP_DEBUG', false); require_once(ABSPATH . 'wp-settings.php');
As mentioned in this particular answer, compressing data before encryption may lead to the CRIME attack, especially if the hacker has collected many similar versions of the transmitted data. Let's use the following example for this particular security case: Bob is using an encrypted personal diary program which is stored in a file which is encrypted using AES-256 in CBC mode with a SHA-256 HMAC (or AES-256 in GCM mode). The journal compresses entry text using LZ or DEFLATE compression upon saving them. The journal file structure is a fairly simple BSON tree (think JSON, but binary so no need to escape strings/etc.) which simply compresses the actual journal text upon file saving, but not the journal entry titles, dates, etc. Bob stores this file in a Dropbox folder which is synced across his machines. One of Bob's machines is compromised and Oscar now has access to his Dropbox account. Oscar can download all history for the journal from Dropbox. What is the main attack surface, if any, for Oscar? Does having compressed data in the encrypted journal file offer compromises which Oscar can exploit?
Imagine I have a file encrypted using AES CBC mode with a key and a random IV. The attacker access to the encrypted text and the IV used but not the key. In this scenario there is no vulnerability since the IV is random. Now lets assume the attacker gets information about the plaintext used. The plaintext is a survey form filled out by a user. So there is a fixed format for the data encrypted. In that case if we assume the attacker has access to the empty survey form (with the questions) does that change the presumed security of the encrypted data? The random IV does not matter any more. The situation lends itself to a chosen plaintext attack. Am I missing something here? How do you protect the data in this case? EDIT: The key is randomly generated and stored in a database completely separated from the encrypted data.
I'm wondering if there is an easy way to establish VPN tunnels through other VPN tunnels to get onion routing like properties (sender anonymity). Since VPN builds a tunnel, it should be easy to set up another tunnel in this tunnel to another VPN endpoint, but I have found no documentation on such a setup. It would be interesting to extend this to more than two hops... Why? Tor nodes are public and those IPs are often blocked and reveal that you are using Tor. There are many open VPN nodes and I hope not all of them are malicious, hence getting similar properties like Tor. Does anybody know of such a setup? Preferably using linux ;)
I see a lot of similar question but my is different. I had done a lot of challenges like Kioptrix and De-ice. But I'm not sure that this is real life pen testing. I mean this is so simple only nmap and metasploit (and some web app hacking). So is there something closer to real life penetration testing?
Car manufactures like BMW, Audi or Mercedes-Benz all provide mobile applications to control your car. All apps share really critical functions like remote lock/unlock or the ability to find your car based on current GPS location. Can somebody provide any additional information how this kind of communication is secured? On the BWM app you just have to enter your login information of the BMW connectedDrive Portal and you're set up and have full control over your car. I really doubt the security of real world cars protected with user chosen passwords. My best guess is that some public key infrastructure is used but I can't find any information.
i am new to buffer overflow and learning from securitytube.net website but in 7th video i got stucked Buffer Overflow Primer Part 7 (Exploiting A Program Demo) In this when the value of egg is passed through the vulnerable program on one point 80 bytes are loaded on the stack but mine computer is loading 88 bytes due to which i am not able to smash the stack. I have faced the same problem with the shellcoder's handbook second edition page 33 topic the address problem and nop method. iam using kali linux 32 bit and have disabled the ASLR but still its not working can anyone give me some direction??
I'm a firm proponent of using a password manager like Keepass to generate and store secure passwords. I also encourage others to do the same. But there's always one person who says they'll never use it because it keeps all their passwords in one place, so if an attacker breaks into their Keepass database, they will then have all their passwords. I've been pointing out that the same thing can happen with their email accounts, and that the attacker can just use the "forgot your password?" option to get all their passwords, but it usually doesn't help, and I'm a bit curious about this myself. Does anyone have any more in-depth rebuttals to this?
Would chip-and-PIN have prevented the Target breach? As we all know, Target was breached and the hackers stole lots of credit card numbers. Target is now advocating for chip-and-PIN, as a way to provide better security for credit cards. This makes me wonder. If chip-and-PIN had been in place, would it have prevented the breach? Or would the attack still have been possible (merely forcing the attackers to shift their methods slightly)? Is this just PR, or would chip-and-PIN have made a significant difference against the kind of attack seen in the Target breach? Recall that, in the Target breach, the attackers were able to compromise Target's point-of-sale terminals: not just one of them, but all of them. Is chip-and-PIN secure in that threat model, where the attacker controls the point-of-sale terminals? Does it depend upon whether credit cards contain both a chip and a magstripe (for backwards compatibility with legacy systems), or if they contain just the chip (and no backwards compatibility)? My impression is that the way this gets deployed is: first we have credit cards that support both chip-and-PIN as well as a legacy magstripe; then after some period of time, when there is sufficient deployment of the chip-and-PIN terminals, then credit card companies might start providing credit cards that have only the chip but not the magstripe. Does that affect the analysis? For instance, is the answer that if credit cards had both the chip and the magstripe, then a compromised point-of-sale terminal can steal the credit card number and CVV off the magstripe nad then clone the card, but if credit cards had only a chip, then they couldn't?
Most Linux distributions now use ASLR for many programs, to randomize the layout of memory. How often is the randomness used for this changed? If I re-run the same program multiple times, will it receive the same layout each time, or will it differ every time? Is fresh randomness generated each time the program is run? each time the machine is rebooted? When are the random values refreshed/reset to new values? Does this depend upon the Linux distribution? Does it depend on which region of memory we are talking about (e.g., the executable, dynamic libraries, the stack, the heap, etc.), or is the answer the same for all of them?
Many sites that support multi-factor authentication provide a "do not ask me again for this computer" option. I'm hoping to gain some insight into how this feature could best be implemented. My initial assumption would be that it is implemented using an (ip-locked?) cookie on the users system. This would however seem to drastically weaken security, since if the cookie is stolen, 2fa is essentially defeated (especially if a login-cookie is also stolen). Any ideas?
This is a situation that I have encountered on a number of occasions. I will conduct a web search in Google, a link to a file (.pdf for example) will take you to that file on the server. It opens up in your browser, you can save the file. But when you backtrack through the URL to find out more about the website that holds it, and if there is other information that can aid your search, you are denied access. You are either given an error message or taken to the log in page for a web portal. Which can be accounted for by configuring the server to prevent directory traversal. While I understand the lack of a robot.txt file could contribute to this, some of these sites would not rely on these for protection since a rogue web crawler would just ignore the file anyway. Not to mention the robot.txt would enumerate a lot of your files and directory structure to a hacker. So it would be too much to presume that some of these sites were not protected by physical firewalls, and given the server authentication which denied moving to other parts of the site, that crawling the site could be done without having log in credentials. So what loop holes is the Google crawler exploiting that allows it to bypass possible firewall, server authentication, and portal protection to find out the directory structure of that server and create direct links that allow someone without credentials to see that file?
The following image attempts to explain the diffie-hellman key exchange for people not strong in maths such as myself: I do understand how the colour/paint example illustrates the idea. But I'm a bit confused about how it maps to the use of very large numbers as is the case with the real protocol. In particular the last stages of the image above, Receiving each other's mixture of paint, they add their secret colour and end up with a common secret. This secret is the same colour in the picture. But what if some other secret colours were used, I mean that wouldn't guarantee ending up with the same colour would it? How does that relate to the use of large numbers. Do they end up with the same number as the common secret?
In reading Glenn Greenwald's 2014 book No place to hide, one thing stood out to me as a bit odd. Greenwald details how Edward Snowden was insistent that Greenwald install PGP in order to communicate securely, but Snowden then later (before PGP encrypted communications is available) agrees to talk over OTR-encrypted IM on an unspecified IM network. My boldface in the quote below; this is from page 17 in the hardcover edition. Any typos are likely to be my own. I was uncertain what he had meant about "declining short-term travel": I had expressed confusion about why he was in Hong Kong but certainly hadn't refused to go. I chalked that up to miscommunication and replied immediately. "I want to do everything possible to be involved in this," I told him, suggesting that we talk right away on OTR. I added his user name to my OTR buddy list and waited. Within fifteen minutes, my computer sounded a bell-like chime, signaling that he had signed on. Slightly nervous, I clicked on his name and typed "hello". He answered, and I found myself speaking directly to someone who I assumed had, at that point, revealed a number of secret documents about US surveillance programs and who wanted to reveal more. The OTR key exchange is automated, and is supposed to be verified by confirming the key fingerprint ideally out-of-band in a manner that allows both parties to confirm who they are talking to (for example, over phone by the parties recognizing each others' voices, or by means of a shared secret). But Snowden (quite likely with good reason) does not trust the communication channels -- e-mail, basically -- that he has available to Greenwald to not at least be monitored, and he probably wouldn't trust them to not be tampered with at least to some degree. Snowden doesn't actually share any documents before PGP encrypted email is available (that is basically stated on pages 19-20, again in the hardcover edition), but this still seems to me to present a communications channel bootstrapping problem. Assuming that they have had no previous contact, how would Snowden have been able to positively confirm that he was actually talking to Greenwald, and not someone else, or someone performing a man-in-the-middle attack?
According to https://security.stackexchange.com/a/2531/5002 TLS-SRP allows one to authenticate a client or server without third-party certificates because it uses a shared secret. If you're going to require the parties have a shared secret, how is this any better than agreeing on a pair of signed certificates ahead of time and using those to carry out future authentication and encryption?
Everytime I visit Gmail, Facebook, YouTube, or Yahoo mail, I get a popup "Please update Internet Explorer" (while I'm using Chrome!). I don't have screenshots but this website describes the problem. I followed all steps but it had no impact. I also ran a few virus scans using Kaspersky, then uninstalled Chrome and Firefox and re-installed them, but the virus persisted. I took a backup of all my data and formatted the entire hard drive - including non-system partitions - and re-installed Windows 7 with all the required drivers. I used Internet Explorer but the problem persisted. I have a Kaspersky firewall and antivirus, and MalwareBytes, but neither can detect any malware. I reformatted and re-installed again, to no avail: the problem is still there. I have no idea what to do. My computer technician basically tried the same things, but he couldn't fix it either. I'm really stuck and don't know how to proceed.
Two days ago I asked that question: Are web browser able to use camera without permission? and I got an answer saying : "there have been multiple vulnerabilities in Flash, Chrome and even Facebook" Is there a process to validate that a software developed by a company is safe ? I mean, is it really impossible to prove that a software is safe ? internal or external process ? Thanks a lot
I am looking for a free open source solution that is able to capture and decrypt SSH traffic given the fact that I can provide the server's RSA private key (something like SSH CryptoAuditor). Please advise.
i am trying to exploit a buffer overflow vulnerability in ubuntu (kernel version 3.0.0-12 generic i686) by using the method return to libc and the stack is not exploiting ? By while exploiting i figured out that the address of system call and exit call is of size 3 byte due to which i think i am not able to exploit the stack in the proper way.. can anyone one help out how can i figure out this?? should i add a 0x00 in address
From what I understand in PHP '/etc/passwd/' or '/etc/passwd/./././' should be treated just the same as '/etc/passwd' I am using PHP 5.4 and this does not seem to be true: php -r "include('/etc/passwd'); " works fine but php -r "include('/etc/passwd/'); " Warning: include(/etc/passwd/): failed to open stream: No such file or directory in Command line code on line 1 Warning: include(): Failed opening '/etc/passwd/' for inclusion (include_path='.:') in Command line code on line 1 The same is true for : php -r "include('/etc/./././passwd'); " works! php -r "include('/etc/./././passwd/'); " Warning: include(/etc/./././passwd/): failed to open stream: No such file or directory in Command line code on line 1 Warning: include(): Failed opening '/etc/./././passwd/' for inclusion (include_path='.:') in Command line code on line 1 does not work! Can someone please let me know if I am doing anything wrong or is the path truncation issue fixed?
I see a lot of websites (including Stackoverflow) using this authentication mechanism: Client authenticates under HTTPS and gets back a session id. Client drops back to HTTP and accesses secure pages using HTTP, passing the session id to prove that authentication took place. What's the point of using HTTPS to protect authentication if the man-in-the-middle can simply steal the resulting session id and act as the authenticated client? I understand that session will eventually expire but that still gives the attacker a pretty long window of opportunity to mount an attack.
I'm building an image with openwrt sdk and i want to secure my image (by encrypting filesystem for example).. How can i do that to prevent anyone from seeing my sscripts or programs running ?
Assume a simple struct: struct test { char variable[4]; char variable2; } If I write something like variable[4] = '\0' there is a buffer overflow which modifies variable2. Does ASLR prevent this buffer overflow?
When storing user's passwords that you need to verify against (but not use as plaintext) the current state of the art is: Hash the password Use a salt Use a slow hash function - bcrypt, scrypt, etc. This provides the best possible protection against an attacker who has stolen the password database. It does not solve other issues like phishing, malware, password re-use, etc. But there is one remaining problem: the slow hash function can allow a denial of service attack. A single request burns a lot of CPU, which makes a DOS possible with a relatively small number of concurrent requests, making it difficult to use defences like IP throttling. Given the improving performance of JavaScript in browsers, it may now make sense to do this in the browser. I'm assuming here that the site is using SSL, so the JavaScript is delivered securely. If you're not using SSL, then using a slow hash function is unlikely to be a priority for you. There is at least one JavaScript implementation of bcrypt. But using this in a simple way would introduce two problems: The client needs to fetch the salt from the server. This introduces latency on login and, unless care is taken, can reveal whether a particular user account exists. If hashing is done purely on the client then the benefits of storing hashes are lost. At attacker who has stolen the password hashes can simply login using the hashes. However, I think there are acceptable solutions to both of those problems: The salt can be generated as hash(server_salt + user_name) - where server_salt is a random number that is unique to the server, public, and the same for all users. The resulting hash appears to have the required properties of a salt. The server should do a single, fast, hash operation on the hash it receives. As an example: the server stores SHA-256(bcrypt(salt, password)). The client sends bcrypt(salt, password) then the server applies SHA-256 and checks the hash. This does NOT allow an attacker to conduct a fast offline brute force attack. They can do a fast brute force of SHA-256(password) because password has a limited amount of entropy - 2^50 or 2^60 or so. But a 128-bit bcrypt(salt, password) has entropy or 2^128, so they cannot readily brute force it. So, is this a reasonable and secure approach? I am aware of the general advice to "don't roll your own crypto". However, in this case, I am attempting to solve a problem that is not solved by off-the-shelf crypto. For some basic credibility, this has been looked at by John Steven (a recognised expert in the field) with positive outcome from a "brief" analysis.
I want to share a "honeypot" folder on a Windows 7 machine connected to a router. The only shared folder in the local workgroup connected to this router is the honeypot folder, which allows unrestricted access to anyone on the local network. I want to then allow anybody in range to connect to the router via unsecured wireless. How safe is this? With basic Windows security auditing on the honeypot folder, how specific is the information that I can I get on anyone who accesses it with wireless? I don't have any interest in a honeypot exposed to the internet at large via SSH, FTP, etc., and I'm only interested in attempts to access this shared folder via wireless.
I am writing an OpenSSL SSL enabled client application which connects to a Google server. I have the SSL working and I can monitor the traffic and see that it is definitely encrypted. I am using OpenSSL API function SSL_CTX_load_verify_locations to load a .pem file containing public root certificates to verify that the server is a trusted server...I think!? I've done LOADS of searching but I can't find a simple description of what I'm meant to do to make sure I am talking to a Google server. Is using a .pem file with root CA's the correct thing to do? How do I know I'm talking to Google and not someone else on the trusted list? Also, am I meant to distribute the .pem file along with the application, or can it be compiled into my application? Any help greatly appreciated.
In the process of designing a web app that handles public/private key pairs - a Bitcoin web app, specifically - I've had a lot of thought on how to securely handle the storage of the private key, since, using a banking analogy, if someone has access to a user's Bitcoin private key, they have access to all of that user's Bitcoins. In all scenarios the private key is going to be encrypted in a database that's as secure as possible - no direct Internet access, explicit read/write privileges, etc - but the part that I'm trying to determine and figure out the best solution to is the private key deception. I can do it either on the client side, i.e. in the user's browser, or on the server side. If I do it in the server side, I could ensure that it's generated and encrypted cryptographically soundly, but if a malicious person gets access to the server, that malicious person will be able to access any decrypted private keys in memory. I could send it to the browser to hold in its storage but then that can raise problems of man-in-the-middle attacks being able to read the private key in transit. All of the decryption/encryption of the private key would be done on the server, including when the private key is first generated. If I do it client side, I wouldn't have to worry about a malicious person getting the decrypted private key from my server as it would be decrypted in the browser, but since Javascript cryptography isn't as strong as other methods, the encrypted private keys may not be as secure in storage and may be more easily compromised in the case of data theft. I was originally leaning towards doing the encryption/decryption and key-pair generation in the client side, but now I'm not so sure and to me it seems like they both have valid concerns. Considering the state of the modern browser and its advancements in Javascript cryptography, are the benefits/risks of encryption/decryption in the browser better than the benefits/risks of doing it on the server? Note for this scenario please only consider that the private key would only either reside on the server in memory, or in the browser in memory/localStorage.
I'd like to change the CSR before it is transferred to the CA without going through the CSR creation process again. To do that I need to know how to calculate the signature of the CSR after I modified it. Unfortunately I couldn't find out exactly how many bytes of the CSR are hashed. I created the CSR like this: openssl req -out certrequest.csr -new -newkey rsa:2048 -nodes -keyout private.key After sed -e '1d' -e '$d' certrequest.csr \| openssl enc -base64 -d > certrequest-stripped the last 256 bytes (sha256WithRSAEncryption) of certrequest-stripped are signature1. Now I'd like to know how many of the first bytes of certrequest-stripped I have the hash in order to sign the hash using the private key. In other words, I'm looking for the value of the "?" in the following command so that both signatures (signature1 and signature2) match: head -c <?> certrequest-stripped \| openssl dgst -sha256 > hash openssl rsautl -sign -inkey private.key -keyform PEM -in hash > signature2 I know that the cut has to be somewhere behind the ASN1 field for the exponent, but since my attempt to increase the head of the CSR byte by byte failed, I'm worried I'm missing something fundamental here.
I've got some practical questions about SRP when the shared secret must be established online. Is there a way to establish the shared secret online without the use of HTTPS? If you've already used HTTPS to establish the shared secret, why bother with TLS-SRP at all? Meaning, what's the advantage of switching to TLS-SRP if you already trust HTTPS? https://security.stackexchange.com/a/2531/5002 claims that "SRP stores the password on the server in a non-recoverable [...] way." What prevents an attacker from figuring out the user's password using a brute-force attack in the same way we attack databases that store password hashes?
What is blind SQL injection, and how does it differ from normal SQL injection? How can I simulate an issue of blind injection?
I'm looking at whats nessecary to create a small accounts server for a video game I'm programming in my spare time. User privacy is a very important topic for me, and I don't want to keep anything about my users that isn't really needed to provide the service I'm offering. I don't feel I have the right require that info, and I don't really want the responsibility of protecting that info (Don't get me wrong though I'll still do whatever is nessecary to protect what I do take). My primary idea for this is to store unsalted email hashes as the account identifiers, the usual salt+hash password, and no other identifying information. I haven't really seen mention of this done previously so I'd like to confirm that the idea is sound. With this system I can still send emails to users for things like password recovery since they will still need to send me their plaintext email to log in. Is this a good idea? If I retain IP addresses for logging purposes and link IPs to accounts, will a hacker be able to match the IPs elsewhere and work out/guess many emails anyway? Is a large list of user IPs valuable to anyone? Are there any other methods for minimising identifying and private information while still ensuring that each user can only log into their own account (such as password alternatives)?
So, I've come across a couple of devices that are using default writable community names for SNMP such as 'private' (on windows machines) and 'Secret c0de' (on Brocade switches). I'm aware of the implications in terms of using SNMP for recon, and i'm aware of the attacks against Cisco devices to both reset the device passwords and to dump the configuration of the switch. With that in mind, it appears that back in the day it was possible to dump hashes from Windows machines by running something along the lines of C:\NTRESKIT>snmputil walk public .1.3.6.1.4.1.77.1.2.25 Unfortunately, that no longer works for more modern versions of Windows (I'm actually testing a relatively up-to-date server 2003 box and it's not working) and I'm curious if there's any other methods to dump passwords (Local/Domain hashes or anything else) via SNMP available (either for Windows or for other switches like the aforementioned Brocade switches). Is there anything else a writeable SNMP community string might be useful for as an attacker that I'm forgetting?
I just asked myself that when you have bitcoin network, which is as we know "pseudo" anonym. Because of the transaction logs of the network (which are afaik endless), it seems that transactions are traceable. But my question is how traceable am i when i am using a bitcoin client with something like tor or other networks like i2p or such.
My current situation is: Site 2 can connect to site 1 via VPN. I'm on site 3. IT at site 1 doesn't allow creating a new VPN to site 1. I'm thinking of using a Remote Desktop via VPN from site 3 to site 2, and the remote PC (in site 2) will connect to site 1. My questions are: Is this possible? What kind of configuration do I need to setup in site 1 and site 2?
I'm migrating users from custom application-level authentication security (built into the app, using username as the unique identifier) to security as a service (using ThinkTecture's Identity Server and MembershipReboot). A substantial number of existing users have non-unique or null email addresses. These will all be seeded from the existing app to MembershipReboot's database. The forgotten password process (using a username field to generate and send an OTP via SMS) is being replaced with MembershipReboot's forgotten credential process using email addresses to generate a URL for users to reset their password. For those users with a shared email address should I include a separate step to capture the username after capturing the users email address to generate a URL for the correct user? Or is there a reasonable alternative that doesn't require any proactive user change?
Based on my understanding, avoiding the use of cookies as an authentication mechanism prevents CSRF vulnerabilities entirely (namely token based authentication in an SPA), when authenticated. Does this also render CSRF checks on the login page / API endpoint itself unnecessary? As far as I can see, even though we could be tricked into sending requests to it unwittingly, there'd be no effect of this - because we're not using cookies to authenticate on subsequent requests. However, I wanted to check with your collective wisdom - can we avoid them on the login page? And what about other non-authenticated pages like password resets?
Today, I received a mail from fb saying that two of my friends have mentioned me in a comment. When I opened fb to see that comment, it was filled with random names (which obviously were their friends/friend-of-friends) and mine was one of them. And the topic of the comment was an advertisement proclaiming a hack to reveal any fb user's username and password. It then gave a bunch of instructions asking you to visit the user's page, opening the browser web-console and pasting some code there. It claimed that doing so would reveal the said user's fb username and password (which is obviously absurd). fb username of this topic poster was Beauty.20000. But whats going on here? Is this an attempt at social engineering (as I suspect) ?
I am putting together a presentation comparing CDN services that also provide DDoS protection. I have to do a really good job on this and I'm not a security expert. For lack of direction, I've copied most of these from a comparison article and could use a little feedback. I don't want a recommendation for a specific service, just to know what features I should have in the presentation based on best practices and your real life experience. Here are the features I look at to compare among the services: Acceleration (network resources, content optimization, connection optimization, caching capabilities) Web Application Security (WAF, PCI compliant, custom security rules, two factor authentication) DDoS (Layer 3-4, Layer 7) Availability (local failover & balancing, global failover & balancing) Price (ADC package, potential extra charges) Are there any features you would add in addition to this? The site operates on a heavily customized Joomla core and will be used for distribution of e-content (mostly images, mostly ~500KB). At launch we do not plan to use it for any kind of direct sales, but we may have a premium subscription down the road (hence PCI compliant).
In our app (PHP, MySQL) we allow users to create templates which are stored in their own subdirectory (which is named by the template name). Someone suggested to use standard file name sanitization but I am not too comfortable to allow user to name their template 'mytemplate.php' IS allowing extensions on directory names a security risk?

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.