企业版API接入（支持加密）

Des 加密功能可以防止明文 HTTP 请求在传输过程中被恶意篡改，使用加密功能需申请企业版本。具体使用方式如下：

1. 开通企业版本

仅 HttpDNS 企业版本可以使用加密功能，将收到授权 ID 和密钥，请妥善保管、切勿泄漏。

2. 基本步骤

第一步：查收您邮件中的授权 ID 和对应的密钥；
第二步：将查询的域名（如客户指定用 IP，则 IP 需要加密）用授权 ID 和密钥，以 Des 的 ECB 方式进行加密，填充方式为 PKCS5Padding。
第三步：发送加密的请求；
第四步：接受加密的应答；
第五步：将结果解密，最终获得所查询的域名对应的解析结果。

下面以 Android 为例说明：

3. Android 示例

3.1 加密发送请求

先将要查询的域名用您收到的邮件中的ID对应的密钥，以 Des 的 ECB 方式进行加密，填充方式为 PKCS5Padding。如果需要指定 IP 参数，IP 参数也用同样的方法加密。

try {
//初始化密钥
SecretKeySpec keySpec = new SecretKeySpec(encKey.getBytes("utf-8"), "DES");
//选择使用DES算法，ECB方式，填充方式为PKCS5Padding
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
//初始化
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
//获取加密后的字符串
encryptedString = bytesToHex(cipher.doFinal(hostName.getBytes("utf-8")));
} catch (Exception e) {
e.printStackTrace();
}

3.2 发送请求

域名加密后，向 HttpDNS 服务器发起请求：

//dn参数对应为加密后的字符串，id 对应为您的密钥 ID
dn=ac7875d400dacdf09954edd788887719&ip=30958d601665478905668b8556976250&id=1&ttl=1

3.3 接受加密应答

当您将加密后的请求发送给 HttpDNS 后，客户端将会收到一串加密后的结果：

`60a111ecb44008ac1b32d1fdfb42aa8a96bade20444421dcf83362072c84cf2ad8f870dfb0a1e448`

3.4 结果解密

try {
//初始化密钥
SecretKeySpec keySpec = new SecretKeySpec(encKey.getBytes("utf-8"), "DES");
//选择使用 DES 算法，ECB 方式，填充方式为 PKCS5Padding
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
//初始化
cipher.init(Cipher.DECRYPT_MODE, keySpec);
//获取解密后的字符串
decryptedString = cipher.doFinal(hexToBytes(s));
} catch (Exception e) {
e.printStackTrace();
}

至此，您已获得解密后的域名解析结果。

4. 加解密测试

如果需要进行测试，可以使用以下加密及解密测试功能（此功能仅针对已申请企业版的用户开放）：

加密：

http://119.29.29.29/en?v=www.google.com&k=weijianliao

解密：

http://119.29.29.29/de?v=cd52888ecabcac455a14ddbac7f03d97&k=weijianliao

附：iOS示例

MSDKDnsInfoTool.h

//
//  MSDKDnsInfoTool.h
//  MSDKDns
//
//  Created by Mike on 3/25/16.
//  Copyright © 2016 Tencent. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface MSDKDnsInfoTool : NSObject

+ (NSString *) encryptUseDES:(NSString *)plainText key:(NSString *)key;
+ (NSString *) decryptUseDES:(NSString *)cipherString key:(NSString*)key;

@end

MSDKDnsInfoTool.m

//
//  MSDKDnsInfoTool.m
//  MSDKDns
//
//  Created by Mike on 3/25/16.
//  Copyright © 2016 Tencent. All rights reserved.
//

#import "MSDKDnsInfoTool.h"
#import <CommonCrypto/CommonDigest.h>
#import <CommonCrypto/CommonCrypto.h>

@implementation MSDKDnsInfoTool

char MSDKDnsByteToHexByte(char byte) {
    if (byte < 10) {
        return byte + '0';
    }
    return byte - 10 + 'a';
}

void MSDKDnsByteToHexChar(char byte, char *hex) {
    hex[0] = MSDKDnsByteToHexByte((byte >> 4) & 0x0F);
    hex[1] = MSDKDnsByteToHexByte(byte & 0x0F);
}

NSString * MSDKDnsDataToHexString(NSData *data) {
    char hex[data.length * 2 + 1];
    const char *bytes = (const char *)data.bytes;
    for (NSUInteger i = 0; i < data.length; ++i) {
        MSDKDnsByteToHexChar(bytes[i], &hex[i * 2]);
    }
    hex[data.length * 2] = 0;
    return [NSString stringWithUTF8String:hex];
}

char MSDKDnsHexByteToChar(char hex) {
    if (hex >= '0' && hex <= '9') {
        return hex - '0';
    }
    if (hex >= 'a' && hex <= 'f') {
        return hex - 'a' + 10;
    }
    if (hex >= 'A' && hex <= 'F') {
        return hex - 'A' + 10;
    }
    return 0;
}

char MSDKDnsHexCharToChar(char high, char low) {
    high = MSDKDnsHexByteToChar(high);
    low = MSDKDnsHexByteToChar(low);
    return (high << 4) | low;
}

+ (NSString *) encryptUseDES:(NSString *)plainText key:(NSString *)key {
    NSData *srcData = [plainText dataUsingEncoding:NSUTF8StringEncoding];
    size_t dataOutAvilable = ([srcData length] + kCCBlockSizeDES) & ~(kCCBlockSizeDES - 1);
    unsigned char dataOut[dataOutAvilable];
    memset(dataOut, 0x0, dataOutAvilable);
    size_t dataOutMoved = 0;

    char encryptKey[kCCKeySizeDES] = {0};
    strncpy(encryptKey, [key UTF8String], kCCKeySizeDES);

    CCCryptorStatus ccStatus = CCCrypt(kCCEncrypt,
                                       kCCAlgorithmDES,
                                       kCCOptionPKCS7Padding | kCCOptionECBMode,
                                       encryptKey,
                                       kCCKeySizeDES,
                                       NULL,
                                       srcData.bytes,
                                       srcData.length,
                                       dataOut,
                                       dataOutAvilable,
                                       &dataOutMoved);
    if (ccStatus == kCCSuccess) {
        NSData * resultData = [NSData dataWithBytes:dataOut length:(NSUInteger)dataOutMoved];
        return MSDKDnsDataToHexString(resultData);
    }
    return nil;
}

+ (NSString *) decryptUseDES:(NSString *)cipherString key:(NSString *)key {
    if (cipherString && key) {
        const char *tempBytes = [cipherString UTF8String];
        NSUInteger tempLength = [cipherString length];
        if (tempLength > 0) {
            NSUInteger dataLength = tempLength / 2;
            char textBytes[dataLength];
            for (int i  = 0; i < tempLength - 1; i = i + 2)
            {
                char high = tempBytes[i];
                char low = tempBytes[i + 1];
                char hex = MSDKDnsHexCharToChar(high, low);
                textBytes[i / 2] = hex;
            }

            size_t dataOutAvilable = (dataLength + kCCBlockSizeDES) & ~(kCCBlockSizeDES - 1);
            unsigned char dataOut[dataOutAvilable];
            memset(dataOut, 0x0, dataOutAvilable);
            size_t dataOutMoved = 0;

            char decryptKey[kCCKeySizeDES] = {0};
            strncpy(decryptKey, [key UTF8String], kCCKeySizeDES);
            CCCryptorStatus ccStatus = CCCrypt(kCCDecrypt,
                                               kCCAlgorithmDES,
                                               kCCOptionPKCS7Padding | kCCOptionECBMode,
                                               decryptKey,
                                               kCCKeySizeDES,
                                               NULL,
                                               textBytes,
                                               dataLength,
                                               dataOut,
                                               dataOutAvilable,
                                               &dataOutMoved);

            NSString *plainText = nil;
            if (ccStatus == kCCSuccess) {
                NSData *data = [NSData dataWithBytes:dataOut length:(NSUInteger)dataOutMoved];
                if (data) {
                    plainText = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
                }
            }
            return plainText;
        }
    }
    return nil;
}

@end