기본 인증 / 기본 인증서를 사용하는 RESTful API에서 가져 오려고한다고 가정하면 해당 사용자 이름과 암호를 내 프로그램에 저장하는 가장 좋은 방법은 무엇입니까? 지금은 그냥 평문으로 앉아 있습니다.
UsernamePasswordCredentials creds = new UsernamePasswordCredentials("myName@myserver","myPassword1234");
보안에 더 신경을 쓰는 방법이 있습니까?
감사
답변:
인증 시스템을 전체적으로 설계하는 경우 암호가 암호화되어 있더라도 저장해서는 안됩니다. 해시를 저장하고 로그인 중에 제공된 암호가 동일한 해시와 일치하는지 확인합니다. 이렇게하면 데이터베이스의 보안 위반으로 인해 사용자의 암호가 노출되는 것을 방지 할 수 있습니다.
즉, 내적 사고 방식으로 프로세스를 보호하기위한 몇 가지 단계는 다음과 같습니다.
첫 번째 단계는 비밀번호 처리를에서 String로 변경해야합니다 character array.
그 이유는 a String가 immutable객체이므로 객체가로 설정되어 있어도 데이터가 즉시 정리되지 않기 때문입니다 null. 대신 데이터가 가비지 수집 용으로 설정되며 악성 프로그램 String이 정리되기 전에 해당 (암호) 데이터에 액세스 할 수 있기 때문에 보안 문제가 발생 합니다.
이것이 Swing의 JPasswordFieldgetText() 메소드가 더 이상 사용되지 않는 주된 이유 이며 getPassword()문자 배열을 사용하는 이유 입니다.
두 번째 단계는 자격 증명을 암호화하고 인증 프로세스 중에 일시적으로 만 암호를 해독하는 것입니다. 또는 서버 측에서 해시하고 해당 해시를 저장하고 원래 암호를 "잊어 버립니다".
이것은 첫 번째 단계와 유사하게 취약성 시간을 가능한 한 짧게 만듭니다.
자격 증명은 하드 코딩되지 않고 대신 구성 또는 속성 파일 또는 데이터베이스와 같이 중앙 집중식으로 구성 가능하며 쉽게 유지 관리 할 수있는 방식으로 저장하는 것이 좋습니다.
파일을 저장하기 전에 자격 증명을 암호화해야하며, 추가로 파일 자체에 두 번째 암호화를 적용 할 수 있습니다 (자격 증명에 2 계층 암호화, 다른 파일 콘텐츠에 1 계층 암호화).
위에서 언급 한 두 가지 암호화 프로세스는 각각 자체적으로 다중 계층화 될 수 있습니다. 각 암호화는 개념적 예로 Triple Data Encryption Standard (AKA TDES 및 3DES) 의 개별 응용 프로그램이 될 수 있습니다 .
로컬 환경이 적절하게 보호 된 후 (하지만 결코 "안전"하지 않습니다!) 세 번째 단계는 TLS (Transport Layer Security) 또는 SSL (Secure Sockets Layer) 을 사용하여 전송 프로세스에 기본 보호를 적용하는 것 입니다.
네 번째 단계는 다른 보호 방법을 적용하는 것입니다.
예를 들어, "사용할"컴파일에 난독 화 기술을 적용하여 이브, 말로리 또는 다른 사람 이 프로그램을 획득 한 경우 (잠시라도) 보안 조치가 노출되는 것을 방지 합니다. 얘들 아) 그리고 디 컴파일.
업데이트 1 :
@ Damien.Bell의 요청에 따라 다음은 첫 번째 단계와 두 번째 단계를 다루는 예입니다.
//These will be used as the source of the configuration file's stored attributes.
private static final Map<String, String> COMMON_ATTRIBUTES = new HashMap<String, String>();
private static final Map<String, char[]> SECURE_ATTRIBUTES = new HashMap<String, char[]>();
//Ciphering (encryption and decryption) password/key.
private static final char[] PASSWORD = "Unauthorized_Personel_Is_Unauthorized".toCharArray();
//Cipher salt.
private static final byte[] SALT = {
(byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
(byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,};
//Desktop dir:
private static final File DESKTOP = new File(System.getProperty("user.home") + "/Desktop");
//File names:
private static final String NO_ENCRYPTION = "no_layers.txt";
private static final String SINGLE_LAYER = "single_layer.txt";
private static final String DOUBLE_LAYER = "double_layer.txt";
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws GeneralSecurityException, FileNotFoundException, IOException {
//Set common attributes.
COMMON_ATTRIBUTES.put("Gender", "Male");
COMMON_ATTRIBUTES.put("Age", "21");
COMMON_ATTRIBUTES.put("Name", "Hypot Hetical");
COMMON_ATTRIBUTES.put("Nickname", "HH");
/*
* Set secure attributes.
* NOTE: Ignore the use of Strings here, it's being used for convenience only.
* In real implementations, JPasswordField.getPassword() would send the arrays directly.
*/
SECURE_ATTRIBUTES.put("Username", "Hypothetical".toCharArray());
SECURE_ATTRIBUTES.put("Password", "LetMePass_Word".toCharArray());
/*
* For demosntration purposes, I make the three encryption layer-levels I mention.
* To leave no doubt the code works, I use real file IO.
*/
//File without encryption.
create_EncryptedFile(NO_ENCRYPTION, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 0);
//File with encryption to secure attributes only.
create_EncryptedFile(SINGLE_LAYER, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 1);
//File completely encrypted, including re-encryption of secure attributes.
create_EncryptedFile(DOUBLE_LAYER, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 2);
/*
* Show contents of all three encryption levels, from file.
*/
System.out.println("NO ENCRYPTION: \n" + readFile_NoDecryption(NO_ENCRYPTION) + "\n\n\n");
System.out.println("SINGLE LAYER ENCRYPTION: \n" + readFile_NoDecryption(SINGLE_LAYER) + "\n\n\n");
System.out.println("DOUBLE LAYER ENCRYPTION: \n" + readFile_NoDecryption(DOUBLE_LAYER) + "\n\n\n");
/*
* Decryption is demonstrated with the Double-Layer encryption file.
*/
//Descrypt first layer. (file content) (REMEMBER: Layers are in reverse order from writing).
String decryptedContent = readFile_ApplyDecryption(DOUBLE_LAYER);
System.out.println("READ: [first layer decrypted]\n" + decryptedContent + "\n\n\n");
//Decrypt second layer (secure data).
for (String line : decryptedContent.split("\n")) {
String[] pair = line.split(": ", 2);
if (pair[0].equalsIgnoreCase("Username") || pair[0].equalsIgnoreCase("Password")) {
System.out.println("Decrypted: " + pair[0] + ": " + decrypt(pair[1]));
}
}
}
private static String encrypt(byte[] property) throws GeneralSecurityException {
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
//Encrypt and save to temporary storage.
String encrypted = Base64.encodeBytes(pbeCipher.doFinal(property));
//Cleanup data-sources - Leave no traces behind.
for (int i = 0; i < property.length; i++) {
property[i] = 0;
}
property = null;
System.gc();
//Return encryption result.
return encrypted;
}
private static String encrypt(char[] property) throws GeneralSecurityException {
//Prepare and encrypt.
byte[] bytes = new byte[property.length];
for (int i = 0; i < property.length; i++) {
bytes[i] = (byte) property[i];
}
String encrypted = encrypt(bytes);
/*
* Cleanup property here. (child data-source 'bytes' is cleaned inside 'encrypt(byte[])').
* It's not being done because the sources are being used multiple times for the different layer samples.
*/
// for (int i = 0; i < property.length; i++) { //cleanup allocated data.
// property[i] = 0;
// }
// property = null; //de-allocate data (set for GC).
// System.gc(); //Attempt triggering garbage-collection.
return encrypted;
}
private static String encrypt(String property) throws GeneralSecurityException {
String encrypted = encrypt(property.getBytes());
/*
* Strings can't really have their allocated data cleaned before CG,
* that's why secure data should be handled with char[] or byte[].
* Still, don't forget to set for GC, even for data of sesser importancy;
* You are making everything safer still, and freeing up memory as bonus.
*/
property = null;
return encrypted;
}
private static String decrypt(String property) throws GeneralSecurityException, IOException {
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
return new String(pbeCipher.doFinal(Base64.decode(property)));
}
private static void create_EncryptedFile(
String fileName,
Map<String, String> commonAttributes,
Map<String, char[]> secureAttributes,
int layers)
throws GeneralSecurityException, FileNotFoundException, IOException {
StringBuilder sb = new StringBuilder();
for (String k : commonAttributes.keySet()) {
sb.append(k).append(": ").append(commonAttributes.get(k)).append(System.lineSeparator());
}
//First encryption layer. Encrypts secure attribute values only.
for (String k : secureAttributes.keySet()) {
String encryptedValue;
if (layers >= 1) {
encryptedValue = encrypt(secureAttributes.get(k));
} else {
encryptedValue = new String(secureAttributes.get(k));
}
sb.append(k).append(": ").append(encryptedValue).append(System.lineSeparator());
}
//Prepare file and file-writing process.
File f = new File(DESKTOP, fileName);
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
} else if (f.exists()) {
f.delete();
}
BufferedWriter bw = new BufferedWriter(new FileWriter(f));
//Second encryption layer. Encrypts whole file content including previously encrypted stuff.
if (layers >= 2) {
bw.append(encrypt(sb.toString().trim()));
} else {
bw.append(sb.toString().trim());
}
bw.flush();
bw.close();
}
private static String readFile_NoDecryption(String fileName) throws FileNotFoundException, IOException, GeneralSecurityException {
File f = new File(DESKTOP, fileName);
BufferedReader br = new BufferedReader(new FileReader(f));
StringBuilder sb = new StringBuilder();
while (br.ready()) {
sb.append(br.readLine()).append(System.lineSeparator());
}
return sb.toString();
}
private static String readFile_ApplyDecryption(String fileName) throws FileNotFoundException, IOException, GeneralSecurityException {
File f = new File(DESKTOP, fileName);
BufferedReader br = new BufferedReader(new FileReader(f));
StringBuilder sb = new StringBuilder();
while (br.ready()) {
sb.append(br.readLine()).append(System.lineSeparator());
}
return decrypt(sb.toString());
}
모든 보호 단계를 다루는 전체 예는 "어떻게 적용 할 것인가 " 가 아니라 " 단계가 무엇인지" 에 관한 것이기 때문에이 질문에 대해 합리적이라고 생각하는 것보다 훨씬 뛰어납니다 .
내 대답 (마지막으로 샘플링) 이 훨씬 더 커질 것이지만 여기에있는 다른 질문은 이미 해당 단계 의 "방법" 에 대한 것이며 훨씬 더 적절하며 구현에 대한 더 나은 설명과 샘플링을 제공합니다. 각 개별 단계.
[*]-@ Damien.Bell 귀하의 요청을 방치하지 않기 위해 첫 번째 (~) 및 두 번째 단계를 다루는 예제를 포함했습니다. --- 모든 단계가 아닌 이유는 보시다시피 작은 코드 조각으로 샘플링 할 수있는 것이 아닙니다. 그리고 네트워크 보호를위한 예는 부분적으로 의사 코딩 되더라도 로컬 범위보다 더 많은 것을 요구합니다. 또한 난독 화는 매우 광범위한 구현 방법을 가지고 있으며 개념 상 간단하지만 소스 코드 자체에 적용된다는 사실은 샘플로 설명하기 어렵다는 것을 의미합니다.
CharBuffer특별히 내 머리 꼭대기에서 기억하지 못하지만 기본적으로 변경 불가능하지 않은 경우 (내부 데이터를 덮어 쓰거나 null0으로 가져올 수 있습니다. GC를 기다리는 중), 정리하는 것을 잊지 않는 한 사용할 수 있습니다.
기본 인증을 사용하는 경우 base64로 인코딩 된 일반 텍스트로 자격 증명을 전달하지 않도록 SSL과 연결해야합니다. 누군가가 패킷을 스니핑하여 자격 증명을 쉽게 얻을 수 있도록하고 싶지는 않습니다. 또한 소스 코드에 자격 증명을 하드 코딩하지 마십시오. 구성 가능하게 만드십시오. 구성 파일에서 읽으십시오. 자격 증명을 구성 파일에 저장하기 전에 암호화해야하며 앱은 구성 파일에서 자격 증명을 읽은 후 암호를 해독해야합니다.
일반적으로 자격 증명을 암호화하는 것은 좋은 조언이 아닙니다. 암호화 된 것은 해독 할 수 있습니다. 공통 가장 좋은 방법은 같은 암호를 저장하는 것입니다 소금에 절인 해시 .A 해시를 해독 할 수 없습니다. Rainbow Tables로 추측하는 무차별 대입을 물리 치기 위해 소금이 추가됩니다 . 모든 사용자 ID가 고유 한 임의의 솔트를 가지고있는 한 공격자는 가능한 모든 솔트 값에 대해 테이블 세트를 생성해야하므로 우주의 수명 내에서이 공격을 빠르게 불가능하게 만들 수 있습니다. 이것이 웹 사이트에서 일반적으로 비밀번호를 잊어 버린 경우 비밀번호를 보낼 수 없지만 '재설정'만 할 수있는 이유입니다. 그들은 귀하의 암호가 저장되지 않고 해시 만 저장됩니다.
암호 해싱은 스스로 구현하기가 그리 어렵지 않지만 수많은 다른 사람들이 해싱을 해주었 기 때문에 해결하는 것은 일반적인 문제입니다. 사용하기 쉬운 jBcrypt를 발견 했습니다 .
암호의 무차별 대입 추측에 대한 추가 보호로서 잘못된 암호로 특정 횟수의 로그인 시도 후 사용자 ID 또는 원격 IP가 몇 초 동안 기다리도록하는 것이 일반적인 모범 사례입니다. 이것이 없으면 무차별 대입 공격자는 서버가 처리 할 수있는만큼의 초당 암호를 추측 할 수 있습니다. 10 초당 100 개의 암호를 추측 할 수있는 것과 백만 개를 추측 할 수있는 것에는 큰 차이가 있습니다.
소스 코드에 사용자 이름 / 비밀번호 조합을 포함 시켰다는 인상을 받았습니다. 즉, 비밀번호를 변경하려는 경우 서비스를 다시 컴파일하고 중지하고 다시 시작해야하며 소스 코드를 보유한 사람도 비밀번호를 가지고 있음을 의미합니다. 일반적인 모범 사례는이 작업을 수행하지 않고 자격 증명 (사용자 이름, 암호 해시, 암호 솔트)을 데이터 저장소에 저장하는 것입니다.
security.Provider이전 버전에서도 쉽게 구현할 수 있으므로 여전히 타사 API가 필요하지 않습니다.
게다가 내가 잊은 수천 가지 것 :)
프로그램이 실행중인 환경을 신뢰할 수 없지만 일반 암호 또는 인증서를 통해 인증해야하는 경우 자격 증명을 보호하기 위해 할 수있는 작업이 없습니다. 당신이 할 수있는 가장 큰 방법은 다른 답변에 설명 된 방법으로 난독 화하는 것입니다.
해결 방법으로 신뢰할 수있는 프록시를 통해 RESTful API에 대한 모든 요청을 실행하고 거기에서 일반 텍스트 비밀번호 인증을 수행합니다.
0및 1메모리에 있기 때문입니다 . ___ 암호화 보안의 기본은 "너무 어렵게 만드는 것은 노력할 가치가 없다"는 것입니다. ___ 마지막으로, 브라우저의 자동 채우기 / 로그인 (웹 사이트 용)을 애플리케이션의 자동 인증 / 로그인 (암호화 된 파일에만 저장 됨)으로 잘못 인식하고 있습니다.
사람들은 왜 해싱에 대해 이야기하고 있습니다. OP는 외부 리소스에 액세스하기 위해 사용자 자격 증명을 저장하려고합니다. 그의 암호를 해싱하는 것은 도움이되지 않습니다.
이제 그것은 길을 벗어났습니다. 모든 레이어에 대해 간단한 모범 사례를 사용합니다.
1 . 자바 앱에 비밀번호 저장. : Char Array로 저장합니다. 암호 저장소 클래스를 만들고 액세스하려는 리소스로 키를 사용하여 암호를 해시 맵으로 저장하고 사용자 이름과 암호를 포함하는 일부 개체로 값을 저장합니다. 일부 인증을 사용하여이 API에 대한 진입 점을 제한합니다. 예 : 로그인 한 사용자의 자격 증명을 수락하여 해당 리소스에 대한 해당 사용자의 액세스 수준을 확인합니다 (사용자를 액세스 할 수있는 암호 목록에 매핑하기 만하면됩니다. 그룹을 많이 생성 한 경우 그리고 해당 그룹에 passwordmap 키 매핑) 비밀번호를 저장하기 위해이 이상의 모든 것은 jvm 자체에 대한 편집증에 따라 유출됩니다.