vmware新建windows11虚拟机加密密码随机生成的解密

已于 2023-12-01 04:59:28 修改
阅读量251 收藏
点赞数
文章标签： 密码学
于 2023-12-01 04:51:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013376071/article/details/134725488
版权

穷举法

#include <windows.h>
#include <stdio.h>

char  Base64_EasyEncode(unsigned __int8* a1, unsigned int a2, BYTE** a3)
{
    char pA2Za2zaddxiegang[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"};
    unsigned int v3; // ebx
    BYTE* v4; // esi
    unsigned int v6; // edx
    unsigned __int8 v7; // al
    unsigned int v8; // eax
    unsigned int v9; // ebx
    unsigned __int8 v10; // cl
    char result; // al
    unsigned int v12; // [esp+Ch] [ebp-8h]

    v3 = a2;
    v12 = (a2 + 2) / 3;
    v4 = (BYTE *)malloc(4 * v12 + 1);
    *a3 = v4;
    if (v4 && a2 + 2 >= a2 && v12 <= (4 * v12) >> 2)
    {
        if (a2 > 2)
        {
            v6 = (a2 - 3) / 3 + 1;
            do
            {
                v3 -= 3;
                *v4 = pA2Za2zaddxiegang[*a1 >> 2];
                v4[1] = pA2Za2zaddxiegang[(a1[1] >> 4) | (16 * (*a1 & 3))];
                v4[2] = pA2Za2zaddxiegang[(a1[2] >> 6) | (4 * (a1[1] & 0xF))];
                v7 = a1[2];
                a1 += 3;
                v4[3] = pA2Za2zaddxiegang[v7 & 0x3F];
                v4 += 4;
                --v6;
            } while (v6);
        }
        v8 = v3;
        v9 = v3 - 1;
        if (v8)
        {
            if (v9)
                v10 = a1[1];
            else
                v10 = 0;
            *v4 = pA2Za2zaddxiegang[*a1 >> 2];
            v4[1] = pA2Za2zaddxiegang[(v10 >> 4) | (16 * (*a1 & 3))];
            if (v9)
            {
                v4[3] = 61;
                v4[2] = pA2Za2zaddxiegang[4 * (v10 & 0xF)];
                result = 1;
                v4[4] = 0;
                return result;
            }
            v4[2] = 61;
            v4[3] = 61;
            v4 += 4;
        }
        *v4 = 0;
        return 1;
    }
    else
    {
        free(v4);
        *a3 = 0;
        return 0;
    }
}


HANDLE g_hZidian = NULL;
void myWriteDist() {
    SYSTEMTIME lt;
    GetLocalTime(&lt);
    char fileName[MAX_PATH] = { 0 };
    sprintf(fileName, "%04d%02d%02d%02d%02d%02d.txt", lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond);
    g_hZidian = CreateFileA(fileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
}

int main() {
    myWriteDist();
    unsigned int uL = 1;
    
    DWORD dwWriteSize = 0;
    BOOL bRet = FALSE;
    
    char szHuanHan[3] = { 0 };
    szHuanHan[0] = 0x0d;
    szHuanHan[1] = 0x0a;

    while (true)
    {
        UCHAR uBuf4[16] = { 0 };
        while (uBuf4[15] == 0)
        {
            for (int i = 0; i < 256; i++) {
                BYTE* pBlock = NULL;
                Base64_EasyEncode(uBuf4, 15, &pBlock);
                while (bRet == FALSE)
                {
                    bRet = WriteFile(g_hZidian, pBlock, 20, &dwWriteSize, NULL);
                    FlushFileBuffers(g_hZidian);
                }
                bRet = FALSE;
                while (bRet == FALSE)
                {
                    bRet = WriteFile(g_hZidian, szHuanHan, 2, &dwWriteSize, NULL);
                    FlushFileBuffers(g_hZidian);
                }
                bRet = FALSE;
                if (uL == 1048575) {
                    CloseHandle(g_hZidian);
                    myWriteDist();
                    uL = 1;
                }
                else
                {
                    uL += 1;
                }
                free(pBlock);
                if (uBuf4[0] + 1 == 256) {
                    if (uBuf4[1] + 1 == 256) {
                        if (uBuf4[2] + 1 == 256) {
                            if (uBuf4[3] + 1 == 256) {
                                if (uBuf4[4] + 1 == 256) {
                                    if (uBuf4[5] + 1 == 256) {
                                        if (uBuf4[6] + 1 == 256) {
                                            if (uBuf4[7] + 1 == 256) {
                                                if (uBuf4[8] + 1 == 256) {
                                                    if (uBuf4[9] + 1 == 256) {
                                                        if (uBuf4[10] + 1 == 256) {
                                                            if (uBuf4[11] + 1 == 256) {
                                                                if (uBuf4[12] + 1 == 256) {
                                                                    if (uBuf4[13] + 1 == 256) {
                                                                        if (uBuf4[14] + 1 == 256) {
                                                                            uBuf4[15] = 1;
                                                                            break;
                                                                        }
                                                                        uBuf4[14] += 1;
                                                                        for (int i = 0; i < 14; i++) {
                                                                            uBuf4[i] = 0;
                                                                        }
                                                                        continue;
                                                                    }
                                                                    uBuf4[13] += 1;
                                                                    for (int i = 0; i < 13; i++) {
                                                                        uBuf4[i] = 0;
                                                                    }
                                                                    continue;
                                                                }
                                                                uBuf4[12] += 1;
                                                                for (int i = 0; i < 12; i++) {
                                                                    uBuf4[i] = 0;
                                                                }
                                                                continue;
                                                            }
                                                            uBuf4[11] += 1;
                                                            for (int i = 0; i < 11; i++) {
                                                                uBuf4[i] = 0;
                                                            }
                                                            continue;
                                                        }
                                                        uBuf4[10] += 1;
                                                        for (int i = 0; i < 10; i++) {
                                                            uBuf4[i] = 0;
                                                        }
                                                        continue;
                                                    }
                                                    uBuf4[9] += 1;
                                                    for (int i = 0; i < 9; i++) {
                                                        uBuf4[i] = 0;
                                                    }
                                                    continue;
                                                }
                                                uBuf4[8] += 1;
                                                for (int i = 0; i < 8; i++) {
                                                    uBuf4[i] = 0;
                                                }
                                                continue;
                                            }
                                            uBuf4[7] += 1;
                                            for (int i = 0; i < 7; i++) {
                                                uBuf4[i] = 0;
                                            }
                                            continue;
                                        }
                                        uBuf4[6] += 1;
                                        for (int i = 0; i < 6; i++) {
                                            uBuf4[i] = 0;
                                        }
                                        continue;
                                    }
                                    uBuf4[5] += 1;
                                    for (int i = 0; i < 5; i++) {
                                        uBuf4[i] = 0;
                                    }
                                    continue;
                                }
                                uBuf4[4] += 1;
                                for (int i = 0; i < 4; i++) {
                                    uBuf4[i] = 0;
                                }
                                continue;
                            }
                            uBuf4[3] += 1;
                            for (int i = 0; i < 3; i++) {
                                uBuf4[i] = 0;
                            }
                            continue;
                        }
                        uBuf4[2] += 1;
                        for (int i = 0; i < 2; i++) {
                            uBuf4[i] = 0;
                        }
                        continue;
                    }
                    uBuf4[1] += 1;
                    for (int i = 0; i < 1; i++) {
                        uBuf4[i] = 0;
                    }
                    continue;
                }
                uBuf4[0] += 1;
                continue;
            }
            
        }

    }
    CloseHandle(g_hZidian);
    return 0;
}

随机看脸解密

#define PY_SSIZE_T_CLEAN
#include <Python.h> //C++和python混合编程的头文件
#include <iostream>
using namespace std;
#pragma comment(lib, "python312.lib")
#include <windows.h>
#include <stdio.h>
#include <bcrypt.h>
#pragma comment(lib, "Bcrypt.lib")
BCRYPT_ALG_HANDLE phAlgorithm;
BCRYPT_ALG_HANDLE dword_10668EB0;
BCRYPT_ALG_HANDLE dword_10668EB4;
BCRYPT_ALG_HANDLE dword_10668EB8;
BCRYPT_ALG_HANDLE dword_10668EBC;
BCRYPT_ALG_HANDLE dword_10668EC0;
BCRYPT_ALG_HANDLE dword_10668EC4;
BCRYPT_ALG_HANDLE dword_10668EC8;
BCRYPT_ALG_HANDLE hObject;
BCRYPT_ALG_HANDLE dword_10668ED0;
BCRYPT_ALG_HANDLE dword_10668ED8;
BCRYPT_ALG_HANDLE dword_10668ED4;
BCRYPT_ALG_HANDLE Context;

LPVOID sub_10065750()
{

    NTSTATUS v3; // eax
    NTSTATUS v5; // eax
    if (BCryptOpenAlgorithmProvider(&phAlgorithm, BCRYPT_RNG_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EB0, BCRYPT_MD5_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EB4, BCRYPT_SHA1_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EB8, BCRYPT_SHA256_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EBC, BCRYPT_SHA384_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EC0, BCRYPT_SHA512_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EC4, BCRYPT_SHA1_ALGORITHM, 0, 8u) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668EC8, BCRYPT_SHA256_ALGORITHM, 0, 8u) < 0
        || BCryptOpenAlgorithmProvider(&hObject, BCRYPT_AES_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668ED0, BCRYPT_AES_ALGORITHM, 0, 0) < 0
        || BCryptOpenAlgorithmProvider(&dword_10668ED8, BCRYPT_RSA_ALGORITHM, 0, 0) < 0)
    {
        return Context;
    }
    BCryptOpenAlgorithmProvider(&dword_10668ED4, BCRYPT_XTS_AES_ALGORITHM, 0, 0);
    v3 = BCryptSetProperty(hObject, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_ECB, 0x20u, 0);
    if (v3 < 0)
    {
        return Context;
    }
    v5 = BCryptSetProperty(dword_10668ED0, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_ECB, 0x20u, 0);
    if (v5 >= 0)
    {
        Context = &phAlgorithm;
        return Context;
    }
    else
    {
        return Context;
    }
}

int  CryptoRandom_GetBytes(PUCHAR pbBuffer, ULONG cbBuffer)
{
    //BCRYPT_ALG_HANDLE* v2 = NULL;
    ULONG v3 = 0;
    PUCHAR v4 = NULL;

    //v2 = (BCRYPT_ALG_HANDLE *)sub_10065750();
    v3 = cbBuffer;
    v4 = pbBuffer;
    UCHAR mypbBuffer[16] = { 0 };
    if (BCryptGenRandom(phAlgorithm, pbBuffer, cbBuffer, 0) >= 0) {
        return 0;
    }
    if (pbBuffer && cbBuffer)
    {
        do
        {
            *v4++ = 0;
            --v3;
        } while (v3);
    }
    return 1;
}

char  Base64_EasyEncode(unsigned __int8* a1, unsigned int a2, BYTE** a3)
{
    char pA2Za2zaddxiegang[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" };
    unsigned int v3; // ebx
    BYTE* v4; // esi
    unsigned int v6; // edx
    unsigned __int8 v7; // al
    unsigned int v8; // eax
    unsigned int v9; // ebx
    unsigned __int8 v10; // cl
    char result; // al
    unsigned int v12; // [esp+Ch] [ebp-8h]

    v3 = a2;
    v12 = (a2 + 2) / 3;
    v4 = (BYTE*)malloc(4 * v12 + 1);
    *a3 = v4;
    if (v4 && a2 + 2 >= a2 && v12 <= (4 * v12) >> 2)
    {
        if (a2 > 2)
        {
            v6 = (a2 - 3) / 3 + 1;
            do
            {
                v3 -= 3;
                *v4 = pA2Za2zaddxiegang[*a1 >> 2];
                v4[1] = pA2Za2zaddxiegang[(a1[1] >> 4) | (16 * (*a1 & 3))];
                v4[2] = pA2Za2zaddxiegang[(a1[2] >> 6) | (4 * (a1[1] & 0xF))];
                v7 = a1[2];
                a1 += 3;
                v4[3] = pA2Za2zaddxiegang[v7 & 0x3F];
                v4 += 4;
                --v6;
            } while (v6);
        }
        v8 = v3;
        v9 = v3 - 1;
        if (v8)
        {
            if (v9)
                v10 = a1[1];
            else
                v10 = 0;
            *v4 = pA2Za2zaddxiegang[*a1 >> 2];
            v4[1] = pA2Za2zaddxiegang[(v10 >> 4) | (16 * (*a1 & 3))];
            if (v9)
            {
                v4[3] = 61;
                v4[2] = pA2Za2zaddxiegang[4 * (v10 & 0xF)];
                result = 1;
                v4[4] = 0;
                return result;
            }
            v4[2] = 61;
            v4[3] = 61;
            v4 += 4;
        }
        *v4 = 0;
        return 1;
    }
    else
    {
        free(v4);
        *a3 = 0;
        return 0;
    }
}

char* genRandomPassCall2()
{
    UCHAR uBuf[16] = { 0 };
    BYTE* pBlock = NULL;
    if (!CryptoRandom_GetBytes(uBuf, 15) && Base64_EasyEncode(uBuf, 15, &pBlock)) {
        return (char *)pBlock;
    }
    else {
        free(pBlock);
        return NULL;
    }
}

int main() {
    sub_10065750();
    Py_Initialize();
    if (!Py_IsInitialized())
    {
        return 0;
    }
    PyRun_SimpleString("import sys");
    PyRun_SimpleString("sys.path.append('./')");
    PyObject* pModule = NULL;
    PyObject* pFunc = NULL;
    pModule = PyImport_ImportModule("hash_hmac");
    if (pModule == NULL)
    {
        return 0;
    }
    pFunc = PyObject_GetAttrString(pModule, "pyvmx");
    unsigned int uTestCount = 0;
    while (true)
    {
        uTestCount++;
        char *pRadomPass = genRandomPassCall2();
        PyObject* pParams = Py_BuildValue("(ss)", "C:\\test.vmx", pRadomPass);
        unsigned int uRandNum = (rand() % (1 - 100 + 1)) + 1;
        if (uTestCount % uRandNum == 0) {
            SYSTEMTIME lt;
            GetLocalTime(&lt);
            char fileName[MAX_PATH] = { 0 };
            sprintf(fileName, "%04d%02d%02d-%02d:%02d:%02d", lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond);
            printf("时间:%s,当前次数:%d,当前尝试密码:%s\r\n", fileName, uTestCount, pRadomPass);
        }
        free(pRadomPass);
        char* result;
        PyObject* pRet = PyObject_CallObject(pFunc, pParams);
        int res = 0;
        PyArg_Parse(pRet, "s", &result);
        char* pFindPass = strstr(result, "Password Found");
        if (pFindPass != NULL) {
            printf("%s\r\n", result);
            DWORD dwWriteSize = 0;
            HANDLE hPass = CreateFileA("pass.txt", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            WriteFile(hPass, result, strlen(result), &dwWriteSize, NULL);
            FlushFileBuffers(hPass);
            CloseHandle(hPass);
            break;
        }
    }
    Py_Finalize();
    return 0;
}

pyvmx.py

#!python3
# -*- coding:utf-8 -*-
#!/usr/bin/python3
from urllib.parse import unquote
from Crypto.Cipher import AES
from binascii import hexlify
import argparse
import hashlib
import random
import base64
import sys
import re
import warnings
warnings.filterwarnings("ignore", category=SyntaxWarning)
retstr = ''
ks_re = '.+phrase/(.*?)/pass2key=(.*?):cipher=(.*?):rounds=(.*?):salt=(.*?),(.*?),(.*?)\)'
ks_struct = {
    'id': None,
    'password_hash': None,
    'password_cipher': None,
    'hash_round': None,
    'salt': None,
    'config_hash': None,
    'dict': None
}

def pyvmx(vmx, dictstr):
    with open(vmx, 'r') as data:
        lines = data.readlines()
    for line in lines:
        if 'encryption.keySafe' in line:
            keysafe = line
    keysafe = unquote(keysafe)
    match = re.match(ks_re, keysafe)
    if not match:
        retstr = 'Unsupported format of the encryption.keySafe line:\n' + keysafe
        return retstr
    vmx_ks = ks_struct
    vmx_ks['id'] = hexlify(base64.b64decode(match.group(1))).decode()
    vmx_ks['password_hash'] = match.group(2)
    vmx_ks['password_cipher'] = match.group(3)
    vmx_ks['hash_round'] = int(match.group(4))
    vmx_ks['salt'] = base64.b64decode(unquote(match.group(5)))
    vmx_ks['config_hash'] = match.group(6)
    vmx_ks['dict'] = base64.b64decode(match.group(7))
    dict_key = hashlib.pbkdf2_hmac('sha1', dictstr.rstrip().encode(), vmx_ks['salt'], vmx_ks['hash_round'], 32)
    dict_aes_iv = vmx_ks['dict'][:AES.block_size]
    cipher = AES.new(dict_key, AES.MODE_CBC, dict_aes_iv)
    dict_dec = cipher.decrypt(vmx_ks['dict'][AES.block_size:-20])
    try:
        if 'type=key:cipher=AES-256:key=' in dict_dec.decode():
            retstr = ("Password Found = %s" % dictstr.rstrip())
    except UnicodeDecodeError:
            retstr = 'Password not found'
    return retstr

小可可恒恒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
VMware Fusion 安装window11跳过TPM加密
少晓年的博客
05-31 255
TPM加密会导致window11的运行性能下降，包括挂起，启动速度都会变慢。
VMware 安装win11
gxt_kt的博客
02-08 3554
VMware 安装win11 使用平台是win11加VMware15pro，目标安装Win11镜像 一切如往常，我以为会和安装win10或者linux一样顺利 知道他提示此电脑不满足安装win11的最低系统要求 突然想起来win11之前因为tmp安全模块炒的很火，上网一搜果然是这个原因 下面放出相关坑点和一些配置 ...
VMware 创建windows11虚拟机
ggtwilight的博客
10-16 429
VM上装Win11虚拟机的步骤流程，以供记录分享。
【Windows】这台电脑无法运行 Windows 11 问题解决
cnskylee的博客
09-23 3776
在使用Vmware Workstation安装 Windows 11最新的内部预览版（v22463.1000）时，会出现下面的报错提示，导致安装中断。 从之前我们了解到的Windows 11安装条件，以及我本地PC的硬件兼容性测试，是完全并且优于微软官方的安装要求（64G内存、500G系统盘）的，其中本地PC的主板还包括了TPM2.0安全模块。因此，我估计是因为虚拟机没有配置TPM安全模块导致了最新版的Windows 11内部预览版无法安装。 下面...
vm虚拟机 加密密码 破解术（亲测可用！）（2.0更新版）
ntrybw的博客
10-12 1万+
为了输入错误，我建议直接在输入完py -v后把虚拟机。vmx文件托进去，保证路径不会出错，然后再加上 -d wordlist.txt(记得-d前面要空一格）然后在这个路径下cmd，进入命令行窗口，先输入pip验证一下python环境，由于这个软件环境是python，所以也需要python环境才可以运行。要解密的虚拟机，就直接把vmx文件拖进去，像我就已经把vmx文件拖进去了。然后就会开始一个一个密码的爆破，直到爆破成功为止，但是时间可能比较长。哈哈哈，虽然我也不知道为啥，可以就是要这样。
VMware——Win11设置登录不需要设输入密码方法
qq_37233070的博客
04-03 2332
一、查看登录用户名 找到登录使用的用户名 #按windows键就可以看到了 二、打开注册表 win+R 输入 regedit 三、进入注册表相应位置 Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon 四、创建三个属性 AutoAdminLogon 新建DWORD 32 bit value,详见下图。 名字随便起都行，只要你能记住，eg:AutoAdminLogon 值为：1
VMware Workstation如何创建加密虚拟机
09-30
在VMware Workstation中，只有在正确输入解密密码后，用户才能启动和访问加密的虚拟机。这一步骤确保了即使虚拟机的磁盘文件（VMDK）被非法获取，没有密码也无法读取其中的数据，从而保护了敏感信息的安全。 要创建...
虚拟机环境
10-29
对于加壳或加密的病毒，虚拟机能够模拟其执行过程，等待病毒自我脱壳或解密，然后利用特征码查杀法进行清除。 虚拟机的运作机制类似于CPU，它可以取指、译码、执行指令，模拟真实CPU的执行流程。当病毒在虚拟机中...
Vmware VCP 2V0-21.20 (109Q) - ITMaterialsTribe.pdf
03-03
Key Management Server是vSphere Virtual Machine Encryption的一个关键组成部分，它负责加密和解密虚拟机磁盘。vSphere Virtual Machine Encryption提供了一种方法来保护虚拟机数据的安全，防止未经授权的访问。...
crypter:具有高级功能，Python绕过VM，具有AES和Base64加密功能的加密源| Crypter 通过暴力破解解密密钥，然后执行解密的邪恶代码来执行邪恶代码
04-14
特征 独立于操作系统 可以使用AES 256位加密和Base64编码对Python源代码进行加密 3种绕过VM的强大方法（例如VirtualBox，VMware，Sandboxie） 虚拟机绕过方法包括注册表检查进程和文件检查MAC地址
VMware 安装WIN11不加密解决TP问题
oQianYuan的博客
02-01 6321
VMWare 升级到 16.2.0 版本更新以上，因为这个版本开始，提供了对 Win11 软件级别 TPM 的支持。 此前，如果用户一直在启用 TPM 的 VMware Workstation Pro 中使用 Win11 虚拟机，用户必须为每个加密的 VM 设置和输入密码。但是本次更新之后，用户可以移除加密，并加入软件级 TPM 标志来代替，不必每次都要输入密码。 如果你在原来的虚拟机安装方式中选择了加密的方式安装WIN11,进可能需要在执行下面的步骤前先解密驱动器。 ...
怎么加密VMware虚拟机？
最新发布
wenyizhao的博客
01-11 2033
本文主要向大家分享几个加密VMware虚拟机的方法。
2021-11-29 VMware安装win11
jxmh1991@163.com
11-29 5331
在Windows主机中安装VMware，VMware中安装win11虚拟机。 物理主机是Windows，有2台，分别是win7和win10。截止笔者记录时，VMware发布到16版本，笔者在安装过程中发现win7主机不支持安装16版本的安装，提示必须在win8以上操作系统安装，所以在win7主机中安装15版本，win10主机安装16版本。 在VMware中安装win11虚拟机 VMware...
VMware虚拟机安装Windows11（无需设置TPM密码）
一码平川
06-01 1万+
通过修改配置文件开启TPM2.0
安装和配置 VMWare vCenter Server 6.7
04-07
通过这一个课程的介绍，我们将了解到 VMWare vCenter 6.7 的基本应用场景，基本架构，并且完成 vCenter Server 6.7 的安装和配置，统一管理 ESXi 主机，虚拟机的运行环境，实现虚拟机的高级功能和可用性可靠性功能。
VMware虚拟机中Windows系统用户密码的清除方法(亲测可用)
波波诸葛伟
11-12 1万+
0X01 Windows用户密码清除 步骤1：制作老毛桃PE的ISO系统镜像 步骤2：设置延长VMware虚拟机启动画面时间 编辑虚拟机配置文件(后缀为.vmx)，在最后行添加：bios.bootDelay=”10000” (此时是以毫秒计算，数字1000就代表1秒，大家可以按照自己的意愿设置延长的时间) 虚拟机启动画面停留时间太短，无法进入VMware虚拟机的BIOS设置界面。可采用该...
虚拟机加密作为服务器,VMware Workstation如何创建加密虚拟机
weixin_32770297的博客
07-30 1403
用户需要输入解密密码才能访问已加密的虚拟机。没有解密密码，就无法访问加密虚拟机的VMDK文件。VMware Workstation加密位于物理计算硬件的启动密码之上。如果是物理计算机，你可以轻松地取出它的硬盘然后安装在任意一个位置就能访问硬盘上的数据。VMware Workstation的加密特性能够防止非授权用户访问虚拟机的敏感数据。本文带你了解采用Workstation加密技术对虚拟机访问进行...
虚拟机加密
weixin_33749131的博客
12-17 1419
2019独角兽企业重金招聘Python工程师标准>>> ...
Window2012R2 忘记密码解决办法
热门推荐
yangyikun0428的博客
08-08 1万+
推荐：ISO映像修复法（步骤复杂但方法管用） 以WMware虚拟机中WindowServer2008R2忘记开机密码为例。 1）配置虚拟主机的CD-ROM 启动VMware虚拟机程序→选中WindowServer2008R2虚拟主机→编辑虚拟机设置→CD-DVD(SATA)→连接→使用ISO映像文件→最后“确定”。 2）进入安装Window...
VMware安装Windows95虚拟机详细步骤
"本教程详述了如何在VMware中安装Windows 95虚拟机，包括新建虚拟机、配置系统、分区、格式化、安装文件、安装驱动等步骤，适用于想要体验经典操作系统或进行相关实验的用户。" 在VMware中安装Windows 95虚拟机的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值