登录 注册

openstack 云主机密码问题

本贴最后更新于 3114 天前，其中的信息可能已经物是人非

openstack云主机的密码有三种方法：

第一种：通过私钥来解密获取到的密码

         获取当前用户的密码，管理员或者其他用户 。

          前提条件：创建的时候导入了使用秘钥。

创建云主机的时候，使用密钥对创建，密码随机生成，用公钥加密，私钥解密。

私钥在创建秘钥对的时候提供下载，这个是2048位的，未经过PKCS#8编码的私钥文件，在Java里面不能直接使用，需要在Linux上执行# openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt 转换成pkcs8编码格式。

同时通过接口获取到的密码是公钥加密过的，并且经过base64编码过，在进行解码的时候，需要通过BASE64Decoder这个类解码后，再用私钥进行解码。在解码过程中，需要注意：

1、私钥长度是2048，缓存区长度需要设置相应长度；

2、  私钥需要转换pkcs8编码格式；

3、  接口获取的密码需要BASE64Decoder解码。

附测试源代码： 

package com.liuxin.openstack;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.security.InvalidKeyException;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.NoSuchAlgorithmException;  
import java.security.SecureRandom;  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
import java.security.spec.InvalidKeySpecException;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;


import org.bouncycastle.jce.provider.BouncyCastleProvider;


import sun.misc.BASE64Decoder;


public class RSAEncrypt {


private static final String DEFAULT_PUBLIC_KEY=   
    "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w" + "\r" +  
    "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht" + "\r" +  
    "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg" + "\r" +  
    "XIlk3gdhnzh+uoEQywIDAQAB" + "\r";  
  
private static final String DEFAULT_PRIVATE_KEY=  
    "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG" + "\r" +  
    "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4" + "\r" +  
    "1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA" + "\r" +  
    "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm" + "\r" +  
    "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j" + "\r" +  
    "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo" + "\r" +  
    "MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ" + "\r" +  
    "DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM" + "\r" +  
    "6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ" + "\r" +  
    "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA" + "\r" +  
    "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX" + "\r" +  
    "TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh" + "\r" +  
    "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo" + "\r" +  
    "1NMLzI2ZfUoX" + "\r";  

/** 
 * 私钥 
 */  
private RSAPrivateKey privateKey;  

/** 
 * 公钥 
 */  
private RSAPublicKey publicKey;  
  
/** 
 * 字节数据转字符串专用集合 
 */  
private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};  
  

/** 
 * 获取私钥 
 * @return 当前的私钥对象 
 */  
public RSAPrivateKey getPrivateKey() {  
    return privateKey;  
}  

/** 
 * 获取公钥 
 * @return 当前的公钥对象 
 */  
public RSAPublicKey getPublicKey() {  
    return publicKey;  
}  

/** 
 * 随机生成密钥对 
 */  
public void genKeyPair(){  
    KeyPairGenerator keyPairGen= null;  
    try {  
        keyPairGen= KeyPairGenerator.getInstance("RSA");  
    } catch (NoSuchAlgorithmException e) {  
        e.printStackTrace();  
    }  
    keyPairGen.initialize(2048, new SecureRandom());  
    KeyPair keyPair= keyPairGen.generateKeyPair();  
    this.privateKey= (RSAPrivateKey) keyPair.getPrivate();  
    this.publicKey= (RSAPublicKey) keyPair.getPublic();  
}  

/** 
 * 从文件中输入流中加载公钥 
 * @param in 公钥输入流 
 * @throws Exception 加载公钥时产生的异常 
 */  
public void loadPublicKey(InputStream in) throws Exception{  
    try {  
        BufferedReader br= new BufferedReader(new InputStreamReader(in));  
        String readLine= null;  
        StringBuilder sb= new StringBuilder();  
        while((readLine= br.readLine())!=null){  
            if(readLine.charAt(0)=='-'){  
                continue;  
            }else{  
                sb.append(readLine);  
                sb.append('\r');  
            }  
        }  
        loadPublicKey(sb.toString());  
    } catch (IOException e) {  
        throw new Exception("公钥数据流读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("公钥输入流为空");  
    }  
}  


/** 
 * 从字符串中加载公钥 
 * @param publicKeyStr 公钥数据字符串 
 * @throws Exception 加载公钥时产生的异常 
 */  
public void loadPublicKey(String publicKeyStr) throws Exception{  
    try {  
        BASE64Decoder base64Decoder= new BASE64Decoder();  
        byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);  
        KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
        X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);  
        this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此算法");  
    } catch (InvalidKeySpecException e) {  
        throw new Exception("公钥非法");  
    } catch (IOException e) {  
        throw new Exception("公钥数据内容读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("公钥数据为空");  
    }  
}  

/** 
 * 从文件中加载私钥 
 * @param keyFileName 私钥文件名 
 * @return 是否成功 
 * @throws Exception  
 */  
public void loadPrivateKey(InputStream in) throws Exception{  
    try {  
        BufferedReader br= new BufferedReader(new InputStreamReader(in));  
        String readLine= null;  
        StringBuilder sb= new StringBuilder();  
        while((readLine= br.readLine())!=null){  
            if(readLine.charAt(0)=='-'){  
                continue;  
            }else{  
                sb.append(readLine);  
                sb.append('\r');  
            }  
        }  
        loadPrivateKey(sb.toString());  
    } catch (IOException e) {  
        throw new Exception("私钥数据读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("私钥输入流为空");  
    }  
}  

public void loadPrivateKey(String privateKeyStr) throws Exception{  
    try {  
        BASE64Decoder base64Decoder= new BASE64Decoder();  
        byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);  
        PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);  
        KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
        this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此算法");  
    } catch (InvalidKeySpecException e) {  
        throw new Exception("私钥非法");  
    } catch (IOException e) {  
        throw new Exception("私钥数据内容读取错误");  
    } catch (NullPointerException e) {  
        throw new Exception("私钥数据为空");  
    }  
}  

/** 
 * 加密过程 
 * @param publicKey 公钥 
 * @param plainTextData 明文数据 
 * @return 
 * @throws Exception 加密过程中的异常信息 
 */  
public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{  
    if(publicKey== null){  
        throw new Exception("加密公钥为空, 请设置");  
    }  
    Cipher cipher= null;  
    try {  
        cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        byte[] output= cipher.doFinal(plainTextData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此加密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    }catch (InvalidKeyException e) {  
        throw new Exception("加密公钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("明文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("明文数据已损坏");  
    }  
}  

/** 
 * 解密过程 
 * @param privateKey 私钥 
 * @param cipherData 密文数据 
 * @return 明文 
 * @throws Exception 解密过程中的异常信息 
 */  
public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{  
    if (privateKey== null){  
        throw new Exception("解密私钥为空, 请设置");  
    }  
    Cipher cipher= null;  
    try {  
        cipher= Cipher.getInstance("RSA/ECB/PKCS1Padding", new BouncyCastleProvider());  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        byte[] output= cipher.doFinal(cipherData);  
        return output;  
    } catch (NoSuchAlgorithmException e) {  
        throw new Exception("无此解密算法");  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
        return null;  
    }catch (InvalidKeyException e) {  
        throw new Exception("解密私钥非法,请检查");  
    } catch (IllegalBlockSizeException e) {  
        throw new Exception("密文长度非法");  
    } catch (BadPaddingException e) {  
        throw new Exception("密文数据已损坏");  
    }         
}  

public static final String PASS="bx8jhAbUOAgMFGXg1jTXWGxYUPn42WlHsu/L16uHWyzOBVoZ+2AhMyIXq2kfw69/xbvjobNcwGMD6t12Q0/4R4EVWGos4Oq0nwwggZ+M+nh30UFUDzibBwGzFpnauToPRJ9iokFipNk9sxvXnyPgPEMiCn2gbBjvelH3J941ZHSVtd6ZDvwzNOvbxDeY86LTjC8aAz+ZpU10MCuE2L0TqGqGU0MqBSyhrq/pF1XrnyNQudPHHbrj+4V/ZNEl4t7z8ge6oizIdvYswrsSsEIFEP5PG4ZVhEKU16JXHMJVixd4kqQDD7vCmx2d4kqyHXynYXnhLN0J4lw8qP/ymEDBXw==";
/** 
 * 字节数据转十六进制字符串 
 * @param data 输入数据 
 * @return 十六进制内容 
 */  
public static String byteArrayToString(byte[] data){  
    StringBuilder stringBuilder= new StringBuilder();  
    for (int i=0; i<data.length; i++){  
        //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移  
        stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);  
        //取出字节的低四位 作为索引得到相应的十六进制标识符  
        stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);  
        if (i<data.length-1){  
            stringBuilder.append(' ');  
        }  
    }  
    return stringBuilder.toString();  
}  


public static void main(String[] args){  
    RSAEncrypt rsaEncrypt= new RSAEncrypt();  
    //rsaEncrypt.genKeyPair();  

    //加载公钥  
    try {  
        rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);  
        System.out.println("加载公钥成功");  
    } catch (Exception e) {  
        System.err.println(e.getMessage());  
        System.err.println("加载公钥失败");  
    }  

    //加载私钥  
    try {  
    	File file=new File("E://pkcs8_priv.pem");
    	FileInputStream in=new FileInputStream(file);
        rsaEncrypt.loadPrivateKey(in); 
        System.out.println("加载私钥成功");  
    } catch (Exception e) {  
        System.err.println(e.getMessage());  
        System.err.println("加载私钥失败");  
    }  

    //测试字符串  
    String encryptStr= "Test String chaijunkun";  

    try {  
        //加密  



//            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());

BASE64Decoder base64Decoder= new BASE64Decoder();

byte[] cipher=base64Decoder.decodeBuffer(PASS);

//解密  xbRrRZiQ19B1s8QNbH6Z

byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);

System.out.println("密文长度:"+ cipher.length);

System.out.println(RSAEncrypt.byteArrayToString(cipher));

System.out.println("明文长度:"+ plainText.length);

System.out.println(RSAEncrypt.byteArrayToString(plainText));

System.out.println(new String(plainText));

} catch (Exception e) {

System.err.println(e.getMessage());

}

}

}

以上是第一种方式。劣势是不可以在后期通过 API 修改密码。

第二种方式，注入脚本

You can convert the content of your bash script to Base64 encoding and pass it to instance when creating it:
String bashScriptContent = Base64(your-bash-script-content);
ServerCreate sc = Builders.server()
.name("instanceName")
.flavor("3")
.image("6c575333-527c-483b-b449-c496be26d368")//centos
.addAdminPass("mypassword")
.userData(bashScriptContent)
.networks(networks)
.build();
Server server = os.compute().servers().boot(sc);

This works with metadata server AFAIK.

FYI, You can directly inject you ssh key to the created machine. You don't need to pass a default password.

在调用API的时候写入脚本。采用的是openstack 4J

  • OpenStack

    OpenStack 是一个云操作系统，通过数据中心可控制大型的计算、存储、网络等资源池。所有的管理通过前端界面管理员就可以完成，同样也可以通过 Web 接口让最终用户部署资源。

    10 引用 • 6 关注
1 赞同
1.5k 10 171 151 166 78 15 64 845

相关帖子

回帖
openstack 云主机密码问题

欢迎来到这里！

我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。

注册 关于
请输入回帖内容 ...
liuxin
回帖
0
 帖子
19
 积分
2055

近期热议

推荐标签 标签

  • Kotlin

    Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，由 JetBrains 设计开发并开源。Kotlin 可以编译成 Java 字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。在 Google I/O 2017 中，Google 宣布 Kotlin 成为 Android 官方开发语言。

    19 引用 • 33 回帖 • 28 关注
  • Vim

    Vim 是类 UNIX 系统文本编辑器 Vi 的加强版本，加入了更多特性来帮助编辑源代码。Vim 的部分增强功能包括文件比较（vimdiff）、语法高亮、全面的帮助系统、本地脚本（Vimscript）和便于选择的可视化模式。

    27 引用 • 66 回帖
  • 开源

    Open Source, Open Mind, Open Sight, Open Future!

    396 引用 • 3416 回帖
  • ZeroNet

    ZeroNet 是一个基于比特币加密技术和 BT 网络技术的去中心化的、开放开源的网络和交流系统。

    1 引用 • 21 回帖 • 590 关注
  • 坑

    一些有用的避坑指南。

    69 引用 • 93 回帖
  • abitmean

    有点意思就行了

    • 22 关注
  • SQLite

    SQLite 是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite 是全世界使用最为广泛的数据库引擎。

    4 引用 • 7 回帖 • 3 关注
  • 尊园地产

    昆明尊园房地产经纪有限公司，即：Kunming Zunyuan Property Agency Company Limited（简称“尊园地产”）于 2007 年 6 月开始筹备，2007 年 8 月 18 日正式成立，注册资本 200 万元，公司性质为股份经纪有限公司，主营业务为：代租、代售、代办产权过户、办理银行按揭、担保、抵押、评估等。

    1 引用 • 22 回帖 • 684 关注
  • 阿里云

    阿里云是阿里巴巴集团旗下公司，是全球领先的云计算及人工智能科技公司。提供云服务器、云数据库、云安全等云计算服务，以及大数据、人工智能服务、精准定制基于场景的行业解决方案。

    89 引用 • 345 回帖
  • FreeMarker

    FreeMarker 是一款好用且功能强大的 Java 模版引擎。

    23 引用 • 20 回帖 • 426 关注
  • 智能合约

    智能合约（Smart contract）是一种旨在以信息化方式传播、验证或执行合同的计算机协议。智能合约允许在没有第三方的情况下进行可信交易，这些交易可追踪且不可逆转。智能合约概念于 1994 年由 Nick Szabo 首次提出。

    1 引用 • 11 回帖 • 8 关注
  • SOHO

    为成为自由职业者在家办公而努力吧！

    7 引用 • 55 回帖 • 93 关注
  • Solo

    Solo 是一款小而美的开源博客系统，专为程序员设计。Solo 有着非常活跃的社区，可将文章作为帖子推送到社区，来自社区的回帖将作为博客评论进行联动（具体细节请浏览 B3log 构思 - 分布式社区网络）。

    这是一种全新的网络社区体验，让热爱记录和分享的你不再感到孤单！

    1425 引用 • 10043 回帖 • 469 关注
  • Kubernetes

    Kubernetes 是 Google 开源的一个容器编排引擎，它支持自动化部署、大规模可伸缩、应用容器化管理。

    108 引用 • 54 回帖 • 1 关注
  • InfluxDB

    InfluxDB 是一个开源的没有外部依赖的时间序列数据库。适用于记录度量，事件及实时分析。

    2 引用 • 55 关注
  • RESTful

    一种软件架构设计风格而不是标准，提供了一组设计原则和约束条件，主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

    30 引用 • 114 回帖
  • 负能量

    上帝为你关上了一扇门，然后就去睡觉了....努力不一定能成功，但不努力一定很轻松 (° ー °〃)

    85 引用 • 1201 回帖 • 449 关注
  • wolai

    我来 wolai：不仅仅是未来的云端笔记！

    1 引用 • 11 回帖 • 2 关注
  • 京东

    京东是中国最大的自营式电商企业，2015 年第一季度在中国自营式 B2C 电商市场的占有率为 56.3%。2014 年 5 月，京东在美国纳斯达克证券交易所正式挂牌上市（股票代码：JD），是中国第一个成功赴美上市的大型综合型电商平台，与腾讯、百度等中国互联网巨头共同跻身全球前十大互联网公司排行榜。

    14 引用 • 102 回帖 • 403 关注
  • Solidity

    Solidity 是一种智能合约高级语言，运行在 [以太坊] 虚拟机（EVM）之上。它的语法接近于 JavaScript，是一种面向对象的语言。

    3 引用 • 18 回帖 • 350 关注
  • jsoup

    jsoup 是一款 Java 的 HTML 解析器，可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API，可通过 DOM，CSS 以及类似于 jQuery 的操作方法来取出和操作数据。

    6 引用 • 1 回帖 • 460 关注
  • OAuth

    OAuth 协议为用户资源的授权提供了一个安全的、开放而又简易的标准。与以往的授权方式不同之处是 oAuth 的授权不会使第三方触及到用户的帐号信息（如用户名与密码），即第三方无需使用用户的用户名与密码就可以申请获得该用户资源的授权，因此 oAuth 是安全的。oAuth 是 Open Authorization 的简写。

    36 引用 • 103 回帖 • 9 关注
  • Lute

    Lute 是一款结构化的 Markdown 引擎，支持 Go 和 JavaScript。

    25 引用 • 191 回帖 • 21 关注
  • 导航

    各种网址链接、内容导航。

    37 引用 • 168 回帖
  • Chrome

    Chrome 又称 Google 浏览器，是一个由谷歌公司开发的网页浏览器。该浏览器是基于其他开源软件所编写，包括 WebKit，目标是提升稳定性、速度和安全性，并创造出简单且有效率的使用者界面。

    60 引用 • 287 回帖
  • 爬虫

    网络爬虫（Spider、Crawler），是一种按照一定的规则，自动地抓取万维网信息的程序。

    106 引用 • 275 回帖
  • Markdown

    Markdown 是一种轻量级标记语言，用户可使用纯文本编辑器来排版文档，最终通过 Markdown 引擎将文档转换为所需格式（比如 HTML、PDF 等）。

    163 引用 • 1450 回帖

最新标签