Me han pedido que actualice algunas macros de Excel 2003, pero los proyectos de VBA están protegidos con contraseña, y parece que falta documentación ... nadie sabe las contraseñas.

¿Hay alguna forma de eliminar o descifrar la contraseña en un proyecto de VBA?

Puede probar este VBAenfoque directo que no requiere edición HEX. Funcionará para cualquier archivo (* .xls, * .xlsm, * .xlam ...).

Probado y trabaja en:

Excel 2007
Excel 2010
Excel 2013 - versión de 32 bits
Excel 2016 - versión de 32 bits

¿Busca la versión de 64 bits? Ver esta respuesta

Cómo funciona

Haré todo lo posible para explicar cómo funciona. Disculpe mi inglés.

1. El VBE llamará a una función del sistema para crear el cuadro de diálogo de contraseña.
2. Si el usuario ingresa la contraseña correcta y hace clic en Aceptar, esta función devuelve 1. Si el usuario ingresa la contraseña incorrecta o hace clic en Cancelar, esta función devuelve 0.
3. Después de cerrar el cuadro de diálogo, el VBE verifica el valor devuelto de la función del sistema
4. si este valor es 1, el VBE "pensará" que la contraseña es correcta, por lo tanto, se abrirá el proyecto VBA bloqueado.
5. El siguiente código intercambia la memoria de la función original utilizada para mostrar el diálogo de contraseña con una función definida por el usuario que siempre devolverá 1 cuando se le llame.

Usando el código

¡Haga una copia de seguridad de sus archivos primero!

1. Abra los archivos que contienen sus proyectos VBA bloqueados

2. Cree un nuevo archivo xlsm y almacene este código en el Módulo 1

   code credited to Siwtom (nick name), a Vietnamese developer

   Option Explicit
   
   Private Const PAGE_EXECUTE_READWRITE = &H40
   
   Private Declare Sub MoveMemory Lib "kernel32" Alias "RtlMoveMemory" _
           (Destination As Long, Source As Long, ByVal Length As Long)
   
   Private Declare Function VirtualProtect Lib "kernel32" (lpAddress As Long, _
           ByVal dwSize As Long, ByVal flNewProtect As Long, lpflOldProtect As Long) As Long
   
   Private Declare Function GetModuleHandleA Lib "kernel32" (ByVal lpModuleName As String) As Long
   
   Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Long, _
           ByVal lpProcName As String) As Long
   
   Private Declare Function DialogBoxParam Lib "user32" Alias "DialogBoxParamA" (ByVal hInstance As Long, _
           ByVal pTemplateName As Long, ByVal hWndParent As Long, _
           ByVal lpDialogFunc As Long, ByVal dwInitParam As Long) As Integer
   
   Dim HookBytes(0 To 5) As Byte
   Dim OriginBytes(0 To 5) As Byte
   Dim pFunc As Long
   Dim Flag As Boolean
   
   Private Function GetPtr(ByVal Value As Long) As Long
       GetPtr = Value
   End Function
   
   Public Sub RecoverBytes()
       If Flag Then MoveMemory ByVal pFunc, ByVal VarPtr(OriginBytes(0)), 6
   End Sub
   
   Public Function Hook() As Boolean
       Dim TmpBytes(0 To 5) As Byte
       Dim p As Long
       Dim OriginProtect As Long
   
       Hook = False
   
       pFunc = GetProcAddress(GetModuleHandleA("user32.dll"), "DialogBoxParamA")
   
   
       If VirtualProtect(ByVal pFunc, 6, PAGE_EXECUTE_READWRITE, OriginProtect) <> 0 Then
   
           MoveMemory ByVal VarPtr(TmpBytes(0)), ByVal pFunc, 6
           If TmpBytes(0) <> &H68 Then
   
               MoveMemory ByVal VarPtr(OriginBytes(0)), ByVal pFunc, 6
   
               p = GetPtr(AddressOf MyDialogBoxParam)
   
               HookBytes(0) = &H68
               MoveMemory ByVal VarPtr(HookBytes(1)), ByVal VarPtr(p), 4
               HookBytes(5) = &HC3
   
               MoveMemory ByVal pFunc, ByVal VarPtr(HookBytes(0)), 6
               Flag = True
               Hook = True
           End If
       End If
   End Function
   
   Private Function MyDialogBoxParam(ByVal hInstance As Long, _
           ByVal pTemplateName As Long, ByVal hWndParent As Long, _
           ByVal lpDialogFunc As Long, ByVal dwInitParam As Long) As Integer
       If pTemplateName = 4070 Then
           MyDialogBoxParam = 1
       Else
           RecoverBytes
           MyDialogBoxParam = DialogBoxParam(hInstance, pTemplateName, _
                              hWndParent, lpDialogFunc, dwInitParam)
           Hook
       End If
   End Function
   

3. Pegue este código debajo del código anterior en el Módulo 1 y ejecútelo

   Sub unprotected()
       If Hook Then
           MsgBox "VBA Project is unprotected!", vbInformation, "*****"
       End If
   End Sub
   

4. Regrese a sus proyectos VBA y disfrute.

Sí, siempre que esté utilizando una .xlshoja de cálculo de formato (el valor predeterminado para Excel hasta 2003). Para Excel 2007 en adelante, el valor predeterminado es .xlsx, que es un formato bastante seguro, y este método no funcionará.

Como dice Treb, es una comparación simple. Un método es simplemente intercambiar la entrada de contraseña en el archivo usando un editor hexadecimal (ver Editores hexadecimales para Windows ). Ejemplo paso a paso:

1. Crea un nuevo archivo simple de Excel.
2. En la parte de VBA, establezca una contraseña simple (digamos - 1234).
3. Guarda el archivo y cierra. Luego verifique el tamaño del archivo - vea el truco de Stewbob
4. Abra el archivo que acaba de crear con un editor hexadecimal.

5. Copie las líneas que comienzan con las siguientes teclas:

   CMG=....
   DPB=...
   GC=...
   

6. PRIMERO COPIA DE SEGURIDAD del archivo de Excel para el que no conoce la contraseña de VBA, luego ábralo con su editor hexadecimal y pegue las líneas copiadas anteriores del archivo ficticio.

7. Guarde el archivo de Excel y salga.
8. Ahora, abra el archivo de Excel en el que necesita ver el código VBA. La contraseña para el código VBA simplemente será 1234 (como en el ejemplo que estoy mostrando aquí).

Si necesita trabajar con Excel 2007 o 2010, hay algunas otras respuestas a continuación que pueden ayudar, particularmente estas: 1 , 2 , 3 .

EDITAR febrero de 2015: para otro método que parece muy prometedor, mire esta nueva respuesta de Đức Thanh Nguyễn.

Me basé en la fantástica respuesta de Đức Thanh Nguyễn para permitir que este método funcione con versiones de Excel de 64 bits. Estoy ejecutando Excel 2010 de 64 bits en Windows 7 de 64 bits.

1. Abra los archivos que contienen sus proyectos VBA bloqueados.

2. Cree un nuevo archivo xlsm y almacene este código en el Módulo 1

   Option Explicit
   
   Private Const PAGE_EXECUTE_READWRITE = &H40
   
   Private Declare PtrSafe Sub MoveMemory Lib "kernel32" Alias "RtlMoveMemory" _
   (Destination As LongPtr, Source As LongPtr, ByVal Length As LongPtr)
   
   Private Declare PtrSafe Function VirtualProtect Lib "kernel32" (lpAddress As LongPtr, _
   ByVal dwSize As LongPtr, ByVal flNewProtect As LongPtr, lpflOldProtect As LongPtr) As LongPtr
   
   Private Declare PtrSafe Function GetModuleHandleA Lib "kernel32" (ByVal lpModuleName As String) As LongPtr
   
   Private Declare PtrSafe Function GetProcAddress Lib "kernel32" (ByVal hModule As LongPtr, _
   ByVal lpProcName As String) As LongPtr
   
   Private Declare PtrSafe Function DialogBoxParam Lib "user32" Alias "DialogBoxParamA" (ByVal hInstance As LongPtr, _
   ByVal pTemplateName As LongPtr, ByVal hWndParent As LongPtr, _
   ByVal lpDialogFunc As LongPtr, ByVal dwInitParam As LongPtr) As Integer
   
   Dim HookBytes(0 To 5) As Byte
   Dim OriginBytes(0 To 5) As Byte
   Dim pFunc As LongPtr
   Dim Flag As Boolean
   
   Private Function GetPtr(ByVal Value As LongPtr) As LongPtr
       GetPtr = Value
   End Function
   
   Public Sub RecoverBytes()
       If Flag Then MoveMemory ByVal pFunc, ByVal VarPtr(OriginBytes(0)), 6
   End Sub
   
   Public Function Hook() As Boolean
       Dim TmpBytes(0 To 5) As Byte
       Dim p As LongPtr
       Dim OriginProtect As LongPtr
   
       Hook = False
   
       pFunc = GetProcAddress(GetModuleHandleA("user32.dll"), "DialogBoxParamA")
   
   
       If VirtualProtect(ByVal pFunc, 6, PAGE_EXECUTE_READWRITE, OriginProtect) <> 0 Then
   
           MoveMemory ByVal VarPtr(TmpBytes(0)), ByVal pFunc, 6
           If TmpBytes(0) <> &H68 Then
   
               MoveMemory ByVal VarPtr(OriginBytes(0)), ByVal pFunc, 6
   
               p = GetPtr(AddressOf MyDialogBoxParam)
   
               HookBytes(0) = &H68
               MoveMemory ByVal VarPtr(HookBytes(1)), ByVal VarPtr(p), 4
               HookBytes(5) = &HC3
   
               MoveMemory ByVal pFunc, ByVal VarPtr(HookBytes(0)), 6
               Flag = True
               Hook = True
           End If
       End If
   End Function
   
   Private Function MyDialogBoxParam(ByVal hInstance As LongPtr, _
   ByVal pTemplateName As LongPtr, ByVal hWndParent As LongPtr, _
   ByVal lpDialogFunc As LongPtr, ByVal dwInitParam As LongPtr) As Integer
   
       If pTemplateName = 4070 Then
           MyDialogBoxParam = 1
       Else
           RecoverBytes
           MyDialogBoxParam = DialogBoxParam(hInstance, pTemplateName, _
                      hWndParent, lpDialogFunc, dwInitParam)
           Hook
       End If
   End Function
   

3. Pegue este código en el Módulo 2 y ejecútelo

   Sub unprotected()
       If Hook Then
           MsgBox "VBA Project is unprotected!", vbInformation, "*****"
       End If
   End Sub
   

DESCARGO DE RESPONSABILIDAD Esto funcionó para mí y lo he documentado aquí con la esperanza de que ayude a alguien. No lo he probado completamente . Asegúrese de guardar todos los archivos abiertos antes de continuar con esta opción.

Hay otra solución (algo más fácil), sin los problemas de tamaño. Utilicé este enfoque hoy (en un archivo XLS 2003, usando Excel 2007) y tuve éxito.

1. Copia de seguridad del archivo xls
2. Abra el archivo en un editor HEX y ubique la DPB=...pieza
3. Cambiar la DPB=...cadena aDPx=...
4. Abra el archivo xls en Excel
5. Abra el editor de VBA ( ALT+ F11)
6. la magia: Excel descubre una clave no válida (DPx) y le pregunta si desea continuar cargando el proyecto (básicamente ignorando la protección)
7. Podrá sobrescribir la contraseña, así que cámbiela por algo que pueda recordar
8. Guarde el archivo xls *
9. ¡Cierra y vuelve a abrir el documento y trabaja tu magia VBA!

* NOTA: Asegúrese de haber cambiado la contraseña a un nuevo valor, de lo contrario, la próxima vez que abra la hoja de cálculo, Excel informará de errores (Error inesperado), luego, cuando acceda a la lista de módulos VBA, verá los nombres de módulos de origen pero reciben otro error al intentar abrir formularios / código / etc. Para remediar esto, regrese a las Propiedades del proyecto VBA y configure la contraseña con un nuevo valor. ¡Guarde y vuelva a abrir el documento de Excel y debería estar listo!

Colin Pickard tiene una excelente respuesta, pero hay un 'cuidado' con esto. Hay casos (aún no he descubierto la causa) en los que la longitud total de la entrada "CMG = ........ GC = ...." en el archivo es diferente de un archivo de Excel al siguiente. En algunos casos, esta entrada será de 137 bytes, y en otros será de 143 bytes. La longitud de 137 bytes es la impar, y si esto sucede cuando crea su archivo con la contraseña '1234', simplemente cree otro archivo, y debería saltar a la longitud de 143 bytes.

Si intenta pegar el número incorrecto de bytes en el archivo, perderá su proyecto VBA cuando intente abrir el archivo con Excel.

EDITAR

Esto no es válido para archivos Excel 2007/2010. El formato de archivo .xlsx estándar es en realidad un archivo .zip que contiene numerosas subcarpetas con el formato, el diseño, el contenido, etc., almacenados como datos xml. Para un archivo de Excel 2007 desprotegido, puede cambiar la extensión .xlsx a .zip, luego abrir el archivo zip y ver todos los datos xml. Es muy sencillo.

Sin embargo, cuando protege con contraseña un archivo de Excel 2007, todo el archivo .zip (.xlsx) en realidad se cifra mediante el cifrado RSA. Ya no es posible cambiar la extensión a .zip y examinar el contenido del archivo.

Para un tipo de archivo .xlsmo .dotmdebe hacerlo de una manera ligeramente diferente.

1. Cambia la extensión del .xlsmarchivo a .zip.
2. Abra el archivo .zip (con WinZip o WinRar, etc.) y vaya a la carpeta xl.
3. Extraiga el vbaProject.binarchivo y ábralo en un Editor Hex (uso HxD , es completamente gratuito y liviano).
4. Busque DPBy reemplace con DPxy guarde el archivo.
5. Reemplace el vbaProject.binarchivo antiguo con este nuevo en el archivo comprimido.
6. Vuelva a cambiar la extensión del archivo a .xlsm.
7. Abra el libro de trabajo para saltar los mensajes de advertencia.
8. Abra Visual Basic dentro de Excel.
9. Vaya a Herramientas> Propiedades del proyecto VBAP> Pestaña Protección.
10. Ingrese una nueva contraseña y guarde el .xlsmarchivo.
11. Cierra y vuelve a abrir y tu nueva contraseña funcionará.

Vale la pena señalar que si tiene un archivo Excel 2007 (xlsm), simplemente puede guardarlo como un archivo Excel 2003 (xls) y utilizar los métodos descritos en otras respuestas.

Con mi turno, esto se basa en la excelente respuesta de kaybee99 que se basa en la fantástica respuesta de Thanc Thanh Nguyễn para permitir que este método funcione con las versiones x86 y amd64 de Office.

Una descripción general de lo que ha cambiado, evitamos push / ret, que está limitado a direcciones de 32 bits y lo reemplazamos con mov / jmp reg.

Probado y trabaja en

Word / Excel 2016 - Versión de 32 bits .
Word / Excel 2016: versión de 64 bits .

cómo funciona

1. Abra los archivos que contienen sus proyectos VBA bloqueados.

2. Cree un nuevo archivo con el mismo tipo que el anterior y almacene este código en el Módulo 1

   Option Explicit
   
   Private Const PAGE_EXECUTE_READWRITE = &H40
   
   Private Declare PtrSafe Sub MoveMemory Lib "kernel32" Alias "RtlMoveMemory" _
   (Destination As LongPtr, Source As LongPtr, ByVal Length As LongPtr)
   
   Private Declare PtrSafe Function VirtualProtect Lib "kernel32" (lpAddress As LongPtr, _
   ByVal dwSize As LongPtr, ByVal flNewProtect As LongPtr, lpflOldProtect As LongPtr) As LongPtr
   
   Private Declare PtrSafe Function GetModuleHandleA Lib "kernel32" (ByVal lpModuleName As String) As LongPtr
   
   Private Declare PtrSafe Function GetProcAddress Lib "kernel32" (ByVal hModule As LongPtr, _
   ByVal lpProcName As String) As LongPtr
   
   Private Declare PtrSafe Function DialogBoxParam Lib "user32" Alias "DialogBoxParamA" (ByVal hInstance As LongPtr, _
   ByVal pTemplateName As LongPtr, ByVal hWndParent As LongPtr, _
   ByVal lpDialogFunc As LongPtr, ByVal dwInitParam As LongPtr) As Integer
   
   Dim HookBytes(0 To 11) As Byte
   Dim OriginBytes(0 To 11) As Byte
   Dim pFunc As LongPtr
   Dim Flag As Boolean
   
   Private Function GetPtr(ByVal Value As LongPtr) As LongPtr
       GetPtr = Value
   End Function
   
   Public Sub RecoverBytes()
       If Flag Then MoveMemory ByVal pFunc, ByVal VarPtr(OriginBytes(0)), 12
   End Sub
   
   Public Function Hook() As Boolean
       Dim TmpBytes(0 To 11) As Byte
       Dim p As LongPtr, osi As Byte
       Dim OriginProtect As LongPtr
   
       Hook = False
   
       #If Win64 Then
           osi = 1
       #Else
           osi = 0
       #End If
   
       pFunc = GetProcAddress(GetModuleHandleA("user32.dll"), "DialogBoxParamA")
   
       If VirtualProtect(ByVal pFunc, 12, PAGE_EXECUTE_READWRITE, OriginProtect) <> 0 Then
   
           MoveMemory ByVal VarPtr(TmpBytes(0)), ByVal pFunc, osi+1
           If TmpBytes(osi) <> &HB8 Then
   
               MoveMemory ByVal VarPtr(OriginBytes(0)), ByVal pFunc, 12
   
               p = GetPtr(AddressOf MyDialogBoxParam)
   
               If osi Then HookBytes(0) = &H48
               HookBytes(osi) = &HB8
               osi = osi + 1
               MoveMemory ByVal VarPtr(HookBytes(osi)), ByVal VarPtr(p), 4 * osi
               HookBytes(osi + 4 * osi) = &HFF
               HookBytes(osi + 4 * osi + 1) = &HE0
   
               MoveMemory ByVal pFunc, ByVal VarPtr(HookBytes(0)), 12
               Flag = True
               Hook = True
           End If
       End If
   End Function
   
   Private Function MyDialogBoxParam(ByVal hInstance As LongPtr, _
   ByVal pTemplateName As LongPtr, ByVal hWndParent As LongPtr, _
   ByVal lpDialogFunc As LongPtr, ByVal dwInitParam As LongPtr) As Integer
   
       If pTemplateName = 4070 Then
           MyDialogBoxParam = 1
       Else
           RecoverBytes
           MyDialogBoxParam = DialogBoxParam(hInstance, pTemplateName, _
                      hWndParent, lpDialogFunc, dwInitParam)
           Hook
       End If
   End Function

3. Pegue este código en el Módulo 2 y ejecútelo

   Sub unprotected()
       If Hook Then
           MsgBox "VBA Project is unprotected!", vbInformation, "*****"
       End If
   End Sub

¿Has intentado simplemente abrirlos en OpenOffice.org?

Tuve un problema similar hace algún tiempo y descubrí que Excel y Calc no entendían el cifrado del otro, por lo que permitieron el acceso directo a casi todo.

Esto fue hace un tiempo, así que si eso no fue solo una casualidad de mi parte, también podría haber sido reparado.

En el caso de que su bloque CMG="XXXX"\r\nDPB="XXXXX"\r\nGC="XXXXXX" en su archivo de 'contraseña conocida' sea más corto que el bloque existente en el archivo de 'contraseña desconocida', rellene sus cadenas hexadecimales con ceros finales para alcanzar la longitud correcta.

p.ej

CMG="xxxxxx"\r\nDPB="xxxxxxxx"\r\nGC="xxxxxxxxxx"

en el archivo de contraseña desconocido, debe establecerse en

CMG="XXXX00"\r\nDPB="XXXXX000"\r\nGC="XXXXXX0000" para preservar la longitud del archivo.

También he tenido esto trabajando con archivos .XLA (formato 97/2003) en Office 2007.

Para Excel 2007 en adelante, debe cambiar su extensión de archivo a .zip. En el archivo hay una subcarpeta xl, allí encontrará vbaProject.bin. Siga el paso anterior con vbaProject.bin y guárdelo nuevamente en el archivo. Modifique de nuevo su extensión y ¡voilà! (es decir, siga los pasos anteriores)

Las contraseñas de proyectos de VBA en documentos de Access, Excel, Powerpoint o Word ( 2007, 2010, 2013 or 2016versiones con extensiones .ACCDB .XLSM .XLTM .DOCM .DOTM .POTM .PPSM) se pueden eliminar fácilmente .

Es simplemente una cuestión de cambiar la extensión del nombre de archivo a .ZIP, descomprimir el archivo y usar cualquier editor hexadecimal básico (como XVI32 ) para "romper" la contraseña existente, lo que "confunde" a Office para que solicite una nueva contraseña la próxima vez que el archivo sea abrió.

Un resumen de los pasos:

• cambie el nombre del archivo para que tenga una .ZIPextensión.
• abre el ZIPy ve a la XLcarpeta.
• extraer vbaProject.biny abrirlo con un editor hexadecimal
• "Buscar y reemplazar" para "reemplazar todo" cambiando DPBa DPX.
• Guarde los cambios, .binvuelva a colocar el archivo en el archivo zip, vuelva a su extensión normal y abra el archivo como siempre.
• ALT + F11 para ingresar al Editor VB y hacer clic derecho en el Explorador de proyectos para elegir VBA Project Properties.
• En la Protectionpestaña, establece una nueva contraseña.
• Haga clic OK, cierre el archivo, vuelva a abrirlo, presione ALT + F11.
• Ingrese la nueva contraseña que configuró.

En este punto, puede eliminar la contraseña por completo si lo desea.

Las instrucciones completas con un video paso a paso que hice "cuando" están en YouTube aquí .

Es sorprendente que esta solución haya estado disponible durante años, y Microsoft no ha solucionado el problema.

La moraleja de la historia?

No se debe confiar en las contraseñas de Microsoft Office VBA Project para la seguridad de ninguna información confidencial . Si la seguridad es importante, use un software de cifrado de terceros.

Colin Pickard es en su mayoría correcto, pero no confunda la protección de "contraseña para abrir" para todo el archivo con la protección de contraseña de VBA, que es completamente diferente de la anterior y es la misma para Office 2003 y 2007 (para Office 2007, cambie el nombre el archivo a .zip y busque el vbaProject.bin dentro del zip). Y que técnicamente la forma correcta de editar el archivo es usar un visor de documentos compuestos OLE como CFX para abrir la secuencia correcta. Por supuesto, si solo está reemplazando bytes, el antiguo editor binario puede funcionar.

Por cierto, si se pregunta sobre el formato exacto de estos campos, ahora lo tienen documentado:

http://msdn.microsoft.com/en-us/library/dd926151%28v=office.12%29.aspx

Si el archivo es un archivo zip válido (los primeros bytes se 50 4Busan en formatos como .xlsm), descomprima el archivo y busque el subarchivo xl/vbaProject.bin. Este es un archivo CFB al igual que los .xlsarchivos. Siga las instrucciones para el formato XLS (aplicado al subarchivo) y luego simplemente comprima el contenido.

Para el formato XLS, puede seguir algunos de los otros métodos en esta publicación. Personalmente prefiero buscar el DPB=bloque y reemplazar el texto

CMG="..."
DPB="..."
GC="..."

con espacios en blanco Esto evita problemas de tamaño de contenedor CFB.

Probé algunas de las soluciones anteriores y ninguna de ellas funciona para mí (excel 2007 xlsm file). Luego encontré otra solución que incluso recupera la contraseña, no solo descifrarla.

Inserta este código en el módulo, ejecútalo y dale algo de tiempo. Recuperará su contraseña por la fuerza bruta.

Sub PasswordBreaker()

'Breaks worksheet password protection.

Dim i As Integer, j As Integer, k As Integer
Dim l As Integer, m As Integer, n As Integer
Dim i1 As Integer, i2 As Integer, i3 As Integer
Dim i4 As Integer, i5 As Integer, i6 As Integer
On Error Resume Next
For i = 65 To 66: For j = 65 To 66: For k = 65 To 66
For l = 65 To 66: For m = 65 To 66: For i1 = 65 To 66
For i2 = 65 To 66: For i3 = 65 To 66: For i4 = 65 To 66
For i5 = 65 To 66: For i6 = 65 To 66: For n = 32 To 126
ActiveSheet.Unprotect Chr(i) & Chr(j) & Chr(k) & _
Chr(l) & Chr(m) & Chr(i1) & Chr(i2) & Chr(i3) & _
Chr(i4) & Chr(i5) & Chr(i6) & Chr(n)
If ActiveSheet.ProtectContents = False Then
MsgBox "One usable password is " & Chr(i) & Chr(j) & _
Chr(k) & Chr(l) & Chr(m) & Chr(i1) & Chr(i2) & _
Chr(i3) & Chr(i4) & Chr(i5) & Chr(i6) & Chr(n)
Exit Sub
End If
Next: Next: Next: Next: Next: Next
Next: Next: Next: Next: Next: Next
End Sub

ElcomSoft fabrica los productos Advanced Office Password Breaker y Advanced Office Password Recovery que pueden aplicarse a este caso, siempre que el documento se haya creado en Office 2007 o anterior.

Tom - Inicialmente cometí un error de colegial ya que no vi el tamaño del byte y en su lugar copié y pegué desde el "CMG" configurado para la entrada posterior. Sin embargo, se trataba de dos tamaños de texto diferentes entre los dos archivos, y perdí el proyecto VBA tal como lo advirtió Stewbob.

Usando HxD, hay un contador que rastrea la cantidad de archivos que está seleccionando. Copie comenzando desde CMG hasta que el contador lea 8F (hexadecimal para 143) y del mismo modo al pegar en el archivo bloqueado - Terminé con el doble del número de "..." al final de la pasta, que parecía extraño de alguna manera y se sentía casi antinatural, pero funcionó.

No sé si es crucial, pero me aseguré de cerrar el editor hexadecimal y sobresalir antes de volver a abrir el archivo en Excel. Luego tuve que ir a través de los menús para abrir el Editor VB, a las Propiedades del Proyecto VB e ingresé la contraseña 'nueva' para desbloquear el código.

Espero que esto ayude.

Mi herramienta, VbaDiff , lee VBA directamente del archivo, por lo que puede usarlo para recuperar el código VBA protegido de la mayoría de los documentos de Office sin recurrir a un editor hexadecimal.

La protección es una simple comparación de texto en Excel. Cargue Excel en su depurador favorito ( Ollydbg es mi herramienta de elección), encuentre el código que hace la comparación y corríjalo para que siempre sea verdadero, esto debería permitirle acceder a las macros.

Para Excel 2016 de 64 bits en una máquina con Windows 10, he usado un editor hexadecimal para poder cambiar la contraseña de un xla protegido (no he probado esto para ninguna otra extensión). Consejo: cree una copia de seguridad antes de hacer esto.

Los pasos que tomé:

1. Abra el vba en el editor hexadecimal (por ejemplo XVI)
2. Buscar en este DPB
3. Cambiar DPB a otra cosa, como DPX
4. Guárdalo!
5. Vuelva a abrir el .xla, aparecerá un mensaje de error, simplemente continúe.
6. Ahora puede cambiar la contraseña de .xla abriendo las propiedades y dirigiéndose a la pestaña de contraseña.

¡Espero que esto haya ayudado a algunos de ustedes!

la extensión de su archivo de Excel cambia a xml. Y ábralo en el bloc de notas. encontrar el texto de la contraseña en el archivo xml.

ves como debajo de la línea;

Sheets("Sheet1").Unprotect Password:="blabla"

(Perdón por mi mal ingles)

Si trabaja en Javausted puede intentarlo VBAMacroExtractor. Después de extraer los scripts de VBA, .xlsmencontré la contraseña en texto sin formato.