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=ac7875d400d*********edd788887719&ip=30958d601665478905********976250&id=1&ttl=1

3.3 接受加密应答

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

`60a111ecb44008ac********fb42aa8a96bade20444*****f83362072c84cf2ad8f870dfb0a1e448`

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=cd52****abcac4********ac7f03d97&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