공유 블로그

Windows11 나만의 윈도우 만들기

공유해드림 — Fri, 24 Apr 2026 20:39:48 +0900

해당 내용은 Windows11에서 진행되었습니다.

Hyper-V로 진행하였습니다

1.Hyper-V 설정[진행률 60%]

Windows 포맷후 전에 깔려있는 프로그램들 한번에 자동 설치 방법 Ver3

해당 내용은 Windows10에서 진행되었습니다. Ver3는 모든 프로그램을 다운로드한 후 iso파일을 패키지로 만드는 과정입니다. 1. 가상머신 설정 [진행률 60%]1-1. Hyper-V 설치 및 세팅 Hyper-V(가상 머신) 활

all-share-source-code.tistory.com

위 링크를 통해 1. 가상머신 설정 [진행률 60%]만진행 해줍니다.

단, windows10 iso 파일 설치 하지 않습니다 아래 Hyper-V windows 11 설치 진행해줍니다.

2. Hyper-V windows 11 설치[진행률 70%]

아래 링크 들어가셔서 윈도우11설치 해줍니다.

Hyper-V windows 11 설치방법

TPM 활성화 방법 보안의 TPM만 활성화 하면 윈도우 11 설치 가능DVD드라이브에 windows11.iso파일 올리고 설치하면 끝출처 : https://m.blog.naver.com/parosaone/222589719218 참고 윈도우 로그인 안하는 방법 : https:/

all-share-source-code.tistory.com

3. 나만의 ISO파일 만들기[진행률 99%]

이것저것 설치 진행해 줍니다.

진행후 윈도우 정상적으로 종료 시킵니다.

https://all-share-source-code.tistory.com/79#3.-%EB%82%98%EB%A7%8C%EC%9D%98-iso%ED%8C%8C%EC%9D%BC-%EB%A7%8C%EB%93%A4%EA%B8%B0-[%EC%A7%84%ED%96%89%EB%A5%A0-99]

Windows 포맷후 전에 깔려있는 프로그램들 한번에 자동 설치 방법 Ver3

all-share-source-code.tistory.com

위 링크(3. 나만의 ISO파일 만들기 [진행률 99%]) 동일하게 진행 합니다.(아래 같은 내)

모두 종료된 상태에서 'Hyper-V관리자' -> 해당 가상 컴퓨터 선택 -> 아래 검사점을 모두 제거합니다. [이미지 참조]

모두 제거된 상태에서 해당 가상 머신 설정에 들어갑니다.

IDE컨트롤러 -> 하드 드라이브 -> 가상 하드 디스크 -> 편집 [이미지 참조]

다음 -> 변환, 다음 -> VHDX, 다음 -> 동적 확장, 다음 -> 찾아보기, 바탕화면에 TEST.vhdx -> 마침 [슬라이더 이미지 참조]

이전다음

5장의 참고 사진 있습니다.

'가상 디스크를 편집하는 중...'이 없어질 때까지 대기합니다.

바탕화면에 해당 이름으로. vhdx확장자로 하나 생성이 된걸 더블클릭해서 실행해 줍니다.

그러면 파일탐색기에 해당 드라이브가 잡혀있는 것을 확인할 수 있습니다.

이전다음

2장의 참고 사진 있습니다.

3-1.RSImageX를 이용한 wim파일 생성

windows 보안에서 실시간 보호를 해제해 줍니다.

RSImageX다운로드 링크 다운로드 진행 후 실행해 줍니다.

생성_이미지추가 -> 탐색(원본 드라이브 OR 폴더) -> 탐색(대상이미지) 후 원하는 .wim파일 이름 입력 -> 이름, windows10 선택 -> WIM파일 생성

▶주의! 이름은 선택창에 있는 이름을 선택하셔야 정상적으로 WIM파일이 작동할 수 있는 확률이 높아집니다.

WIM 파일 생성 후 좀 기다려야 퍼센트다 올라갑니다.

100% 로가 되고 '이미지 생성을 완료했습니다'라고 되었다면 아래 첨부파일을 다운로드합니다.

UltraISO Premium Edition 9.6.6.3300.zip

4.14MB

해당 압축폴더를 풀고 UltraISOPortable.exe를 실행해 줍니다.

Make TEST OS TOOLS(WIN11).iso을 다운로드하여 줍니다.

(용량이 커서 첨부하지 못해 구글드라이브로 공유합니다.)

Make TEST OS TOOLS.iso다운로드한 위치로 가서 열어줍니다. [슬라이더 이미지 참조]

이전다음

2장의 참고 사진 있습니다.

만들어 주었던 wim파일 이름을 install.wim파일로 변경해 줍니다.

'Make TEST OS TOOLS.iso'를 열었던 디스크 안에 sources -> install.wim파일을 덮어씁니다. [이미지 참조]

마지막으로 다른 이름으로 저장합니다.

저장 후 Hyper-V를 켜서 아까 만든 것처럼 가상 컴퓨터를 하나 더 만들고 설정으로 진입합니다. [이미지 참조]

아까와 같이 IDE 컨트롤러 -> DVD드라이브 -> 이미지 파일(해당 다른 이름으로 저장한 iso파일 선택) -> 확인 [이미지 참조]

우클릭 -> 연결 -> 시작 [이미지 참조]

이화면이 나올때 아무키나 눌러주세요

첫번째 탭으로 엔터 해서 들어갑니다.

아래 이미지까지 잘 넘어갔다면 성공입니다!!

만약 아래 이미지와 같이 경고 창이 뜬다면 실패입니다.

이런 에러가 나올경우 install.wim파일이 정확하게 만들어지지 않아서 그렇습니다.

위에 1-1.RSImageX를 이용한 wim파일 생성 통해서 다시 wim파일을 만들어주시기 바랍니다.

4.확인 [100%]

마지막으로 설치까지 완벽하게 해 보고 내가 설치한 모든 프로그램과 설정값이 그대로 인지 확인 하면 끝~

--- 추가 내용 ---

일부 설정값이 안먹히는 것들이 있습니다.

예를 들어 날짜 형식 변경, 확장자 기본값 정의, RaiDrive설정값 등... 일부가 먹히지 않는 경우가 있으니 유의하시고 사용하시면 되겠습니다.

만약 안되는 것들이 있다면 댓글로 남겨주시면 감사하겠습니다.

다른분들도 알아 두면 고생하지 않고 서로서로 알아갈수 있을꺼 같습니다. 감사합니다.

출처 : YM.tech_Computer_LAB *^_^*

DIY 윈도우 우클릭 레지스트리 위치

공유해드림 — Tue, 7 Apr 2026 00:25:45 +0900

1. 주요 메뉴 관리 레지스트리 경로

우클릭 대상(파일, 폴더, 바탕화면 등)에 따라 수정해야 할 경로가 나뉩니다.

대상레지스트리 경로비고

모든 파일	HKEY_CLASSES_ROOT\*\shell	프로그램 실행 항목 등
폴더	HKEY_CLASSES_ROOT\Folder\shell	폴더 우클릭 시 메뉴
바탕화면	HKEY_CLASSES_ROOT\Directory\Background\shell	바탕화면 빈 곳 우클릭 시
확장 프로그램	HKEY_CLASSES_ROOT\*\shellex\ContextMenuHandlers	백신, 압축 프로그램 등

1. 대상별 핵심 경로

대상레지스트리 경로설명

모든 파일	HKEY_CLASSES_ROOT\*\shell	확장자에 상관없이 모든 파일 우클릭 시 노출
일반 폴더	HKEY_CLASSES_ROOT\Directory\shell	실제 폴더를 우클릭했을 때 노출
드라이브	HKEY_CLASSES_ROOT\Drive\shell	C: 드라이브, USB 등 드라이브 우클릭 시
라이브러리	HKEY_CLASSES_ROOT\LibraryFolder\background\shell	라이브러리(문서, 사진 등) 내부 빈 곳 우클릭

2. 조금 더 깊은 설정 (고급)

단순한 실행 메뉴 외에 시스템 서비스나 특수 항목은 아래 경로에 숨어 있는 경우가 많습니다.

ContextMenuHandlers (확장 메뉴):
- HKEY_CLASSES_ROOT\*\shellex\ContextMenuHandlers
- HKEY_CLASSES_ROOT\Directory\shellex\ContextMenuHandlers
- 여기는 일반적인 이름이 아니라 {코드값} 형태로 되어 있으며, 백신 검사나 압축 프로그램(7-Zip, WinRAR) 등의 항목이 주로 위치합니다.

2. 전용 도구 사용 (가장 추천 - 안전함)

레지스트리를 직접 건드리는 건 위험할 수 있어, ShellExView라는 무료 도구를 추천합니다. 윈도우 기본 메뉴 외에 외부 프로그램이 추가한 메뉴만 골라 끄고 켤 수 있습니다.

ShellExView 다운로드 및 실행
Options -> Filter by Extension Type에서 Context Menu 선택
핑크색 배경으로 표시되는 항목(외부 프로그램)들을 선택 후 빨간색 정지 버튼 클릭
우클릭 속도가 다시 빨라졌는지 확인합니다

ShellExView

셸 확장(Shell Extensions)은 Windows 운영 체제의 기능을 확장하는 프로세스 내 COM 개체입니다. 대부분의 셸 확장은 운영 체제에서 자동으로 설치되지만, 다른 응용 프로그램에서 추가 셸 확장 구성 요소를 설치하는 경우도 많습니다. 예를 들어, 컴퓨터에 WinZip을 설치하면 Zip 파일을 마우스 오른쪽 버튼으로 클릭했을 때 WinZip 메뉴가 나타납니다. 이 메뉴는 시스템에 셸 확장을 추가하여 생성됩니다. ShellExView 유틸리티는 컴퓨터에 설치된 셸 확장의 세부 정보를 표시하고 각 셸 확장을 쉽게 활성화 또는 비활성화할 수 있도록 해줍니다.

ShellMenuView

ShellMenuView는 Windows 탐색기에서 파일/폴더를 마우스 오른쪽 버튼으로 클릭했을 때 나타나는 상황별 메뉴 항목 목록을 표시하고, 원하지 않는 메뉴 항목을 쉽게 비활성화할 수 있도록 해주는 작은 유틸리티입니다.

참고

윈도우11 우클릭 메뉴에서 'Windows 터미널에서 열기' 제거 방법

https://sunstar2.tistory.com/2215

윈도우11 우클릭 메뉴에서 'Windows 터미널에서 열기' 제거 방법

윈도우 11은 바탕 화면이나 폴더 등을 우클릭하면 아래 샷처럼 Windows 터미널에서 열기 라는 메뉴가 표시되는데요. 솔직히 저는 이 메뉴가 왜 존재하는지 아직은 이해를 못 하고 있습니다. 'Windows

sunstar2.tistory.com

출처 : GPT

13-be0175au Driver 설치방법

공유해드림 — Mon, 16 Mar 2026 19:20:08 +0900

C:\System.sav\Logs 폴더 생성후 실행할것

Hyper-V GPU사용 방법

공유해드림 — Sat, 6 Dec 2025 02:55:48 +0900

1.Windows Admin Center의 GPUs확장자 설치

Windows Admin Center설치 -> 출처 : https://www.microsoft.com/ko-kr/evalcenter/download-windows-admin-center

Windows Admin Center 설치 화면

01234567

설치후 해당 로그인은 윈도우 계정, 아이디 입력해서 로그인 합니다.

설정 아이콘 클릭

확장 클릭

"사용 가능한 확장" 클릭해서 GPUs검색후 설치 해줍니다.

(저는 이미 설치 되어 있기 때문에 "설치된 확장"에서 확인 됩니다.)

2.그래픽카드 드라이버 설치 확인

그리고 파워쉘 켜줍니다.

그래픽카드 드라이버가 잘 설치 되어 있는지 확인해 줍니다.

(nvidia-smi명령어 안될시 검색해서 설치 진행해주세요...)

3. Hyper-V 그래픽카드 세팅

2개의 사진 있음

Get-VMHostPartitionableGpu | FL Name,ValidPartitionCounts

저는 그래픽카드가 2개기 떄문에 2개로 나옵니다.

둘중 아무거나 선택해서 Name값을 복사해 둡니다.(장치관리자에서 일치하는 값 확인)

{Name아래 있는 값까지 한줄로 복사해야 됩니다!}

$vm = "<가상 컴퓨터 이름>" #변수 할당
Remove-VMGpuPartitionAdapter -VMName $vm #기존에 설치되있는 GPU-P 제거, 처 작업이라면 오류나는게 정상,
Add-VMGpuPartitionAdapter -VMName $vm -InstancePath "<Name값 입력>" #GPU-P 설치("<Name값 입력>"의 GPU로 지정)
Set-VMGpuPartitionAdapter -VMName $vm -MinPartitionVRAM 1 #이하 GPU-P 자원 할당
Set-VMGpuPartitionAdapter -VMName $vm -MaxPartitionVRAM 11
Set-VMGpuPartitionAdapter -VMName $vm -OptimalPartitionVRAM 10
Set-VMGpuPartitionAdapter -VMName $vm -MinPartitionEncode 1
Set-VMGpuPartitionAdapter -VMName $vm -MaxPartitionEncode 11
Set-VMGpuPartitionAdapter -VMName $vm -OptimalPartitionEncode 10
Set-VMGpuPartitionAdapter -VMName $vm -MinPartitionDecode 1
Set-VMGpuPartitionAdapter -VMName $vm -MaxPartitionDecode 11
Set-VMGpuPartitionAdapter -VMName $vm -OptimalPartitionDecode 10
Set-VMGpuPartitionAdapter -VMName $vm -MinPartitionCompute 1
Set-VMGpuPartitionAdapter -VMName $vm -MaxPartitionCompute 11
Set-VMGpuPartitionAdapter -VMName $vm -OptimalPartitionCompute 10
Set-VM -GuestControlledCacheTypes $true -VMName $vm #CPU에서 Write-Combining 사용
Set-VM -LowMemoryMappedIoSpace 1Gb -VMName $vm #32비트 MMIO 공간 구성
Set-VM -HighMemoryMappedIoSpace 32GB -VMName $VM #32비트보다 큰 MMIO 공간 구성

위 명령어를 하면 해당 Hyper-V에 GPU가 설치됩니다.

4. 확인

Get-VMGpuPartitionAdapter -VMName $vm

위 이미지처럼 InstancePath, Name, Id, VMId에 값이 나온다면 정상적으로 설치 완료 된겁니다.

그리고 해당 가상머신을 실행해줍니다.

그러면 장치관리자에 정상적으로 잡혀있는것을 볼수 있습니다.

하지만 드라이버가 없어 세모 표시가 뜨시껍니다. (저는 해결 했기 떄문에 뜨지 않습니다.)

5. 가상머신의 GPU 드라이버 잡기

먼저 가상머신을 닫고 다시 들어가기전 로컬 리소스탭을 클릭해 줍니다.

로컬 장치 및 리소스 -> 자세히 클릭

윈도우가 설치되어 있는 곳 체크(저는 C:드라이브)

그리고 연결 클릭

1.호스트PC의 드라이버를 Hyper-V의 PC에 옮겨주면 됩니다.

호스트PC 드라이버 위치 : "\\tsclient\C\Windows\System32\DriverStore\FileRepository" 의 nv_dispi~~ 또는 nv_dispig~~라고 써있는거를 복사

Hyper-V PC 드라이버 위치 : "C:\Windows\System32\HostDriverStore\FileRepository" 로 붙여 넣기(만약 경로가 없을경우 해당 폴더를 만들어서 붙여 넣어야됩니다.)

2.DLL파일도 옮겨 줘야 됩니다.

호스트PC DLL 위치 : "\\tsclient\C\Windows\System32\nvapi64.dll" 복사

Hyper-V PC 드라이버 위치 : "C:\Windows\System32" 붙여넣기

그리고 Hyper-V PC 재부팅하면 정상적으로 드라이버가 잡혀서 작업관리자에 표시가 되는것을 볼수 있습니다.

출처 : https://m.blog.naver.com/idh3601/222520214248

출처 : https://learn.microsoft.com/ko-kr/windows-server/virtualization/hyper-v/partition-assign-vm-gpu?tabs=powershell

참고

1. 해당 작업 후 고급 세션으로 들어가면 원격 비디오가 바로 끊기는 경우가 있는데, (특히 remotefx를 썼었다면)

기본세션으로 가상 컴퓨터 연결 후 로컬 그룹 정책 편집기(실행에서 gpedit.msc)를 실행하여 컴퓨터 구성 - 관리 탬플릿 - Windows 구성 요소 - 터미널 서비스 - 원격 데스크톱 세션 호스트 - 원격 세션 환경에서 "원격 데스크톱 연결에 대해 WDDM 그래픽 디스플레이 드라이버 사용"을 사용으로 설정해준 다음 재부팅 합니다.

(RemoteFx를 사용하는 경우 사용 안함으로 해야함.)

2. 호스트 pc에서 드라이버가 업데이트 되면, 게스트 pc의 드라이버 또한 위의 작업을 통해 업데이트 해주어야 합니다.

"하나 이상의 GPUP파티션이 할당되어 있어 가상 컴퓨터에서 작업을 수행할 수 없습니다" 오류가 나올시

Hyper-V의 가상 컴퓨터 우클릭 설정 -> 검사점 -> 검사점 사용 체크 해제

검사점을 끄시면 됩니다.

출처 : https://www.reddit.com/r/HyperV/comments/umfi4z/gpu_adapter_for_hyperv_machine/?tl=ko

Hyper-V안 Hyper-V 설정방법(중첩 가상화 방법)

공유해드림 — Fri, 5 Dec 2025 13:39:49 +0900

명령어 한줄이면 끝(파워쉘에서 입력)

Set-VMProcessor -VMName <VMName> -ExposeVirtualizationExtensions $true

<VMName>안에 해당 Hyper-V 이름 입력

출처 : https://learn.microsoft.com/ko-kr/windows-server/virtualization/hyper-v/enable-nested-virtualization

Hyper-V windows 11 설치방법

공유해드림 — Sun, 23 Nov 2025 01:38:25 +0900

TPM 활성화 방법

보안의 TPM만 활성화 하면 윈도우 11 설치 가능

DVD드라이브에 windows11.iso파일 올리고 설치하면 끝

출처 : https://m.blog.naver.com/parosaone/222589719218

참고

윈도우 로그인 안하는 방법 : https://m.blog.naver.com/thkim_arm/223051137091

네트워크 열기 실행 파일(직접 개발)

공유해드림 — Sun, 23 Nov 2025 00:24:01 +0900

네트워크 열기.exe

0.09MB

파이썬 코드 난독화 및 암호화 코드(파이썬 코드 난독화 사이트[Oxyry Python Obfuscator]없어짐에 따라 새로 코드로 개발함)

공유해드림 — Wed, 27 Aug 2025 15:11:36 +0900

Oxyry Python Obfuscator(https://pyob.oxyry.com/)코드 난독화 사이트가 없어져서 그냥 제가 만들었습니다.

왜 없애는지 어차피 이렇게 개발자들이 다시 만들텐데 정말 귀찮게 됐었네요.

필요하신분 아래 코드 또는 첨부 파일 다운받으셔서 난독화_GUI.py 사용하시면 됩니다.

첨부파일

9.코드 암호화.zip

0.01MB

2025/08/30

9.코드 암호화.zip

0.04MB

링크 : https://github.com/all-share-source-code/code-encryption.git

GitHub - all-share-source-code/code-encryption

Contribute to all-share-source-code/code-encryption development by creating an account on GitHub.

github.com

코드

코드_난독화_도구.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
코드 난독화 변환 도구
다양한 난독화 기법을 사용하여 Python 코드를 난독화합니다.
"""

import os
import re
import random
import string
import base64
import zlib
import argparse


class CodeObfuscator:
    """코드 난독화 클래스"""
    
    def __init__(self):
        self.variable_mapping = {}
        self.function_mapping = {}
        self.class_mapping = {}
        self.string_mapping = {}
        self.comment_removed = False
        
    def generate_random_name(self, length: int = 8) -> str:
        """랜덤 변수명 생성"""
        chars = string.ascii_letters + '_'
        return ''.join(random.choice(chars) for _ in range(length))
    
    def remove_comments(self, code: str) -> str:
        """주석 제거"""
        # 한 줄 주석 제거
        lines = code.split('\n')
        cleaned_lines = []
        
        for line in lines:
            # 문자열 내의 #은 보존
            in_string = False
            string_char = None
            cleaned_line = ""
            
            for i, char in enumerate(line):
                if char in ['"', "'"] and (i == 0 or line[i-1] != '\\'):
                    if not in_string:
                        in_string = True
                        string_char = char
                    elif string_char == char:
                        in_string = False
                        string_char = None
                
                if char == '#' and not in_string:
                    break
                cleaned_line += char
            
            if cleaned_line.strip():
                cleaned_lines.append(cleaned_line)
        
        return '\n'.join(cleaned_lines)
    
    def remove_docstrings(self, code: str) -> str:
        """docstring 제거"""
        # 삼중 따옴표 docstring 제거
        code = re.sub(r'""".*?"""', '', code, flags=re.DOTALL)
        code = re.sub(r"'''.*?'''", '', code, flags=re.DOTALL)
        return code
    
    def obfuscate_strings(self, code: str) -> str:
        """문자열 난독화"""
        def replace_string(match):
            original_string = match.group(1)
            if len(original_string) > 3:  # 짧은 문자열은 건너뛰기
                # base64로 인코딩
                encoded = base64.b64encode(original_string.encode()).decode()
                return f'base64.b64decode("{encoded}").decode()'
            return match.group(0)
        
        # 문자열을 base64로 인코딩
        code = re.sub(r'"([^"]*)"', replace_string, code)
        code = re.sub(r"'([^']*)'", replace_string, code)
        
        return code
    
    def obfuscate_variables(self, code: str) -> str:
        """변수명 난독화"""
        # 변수명 패턴 찾기
        variable_pattern = r'\b([a-zA-Z_][a-zA-Z0-9_]*)\s*='
        
        def replace_variable(match):
            var_name = match.group(1)
            if var_name not in ['self', 'cls', '__init__', '__main__', 'if', 'for', 'while', 'def', 'class', 'import', 'from', 'as', 'in', 'is', 'not', 'and', 'or', 'True', 'False', 'None']:
                if var_name not in self.variable_mapping:
                    self.variable_mapping[var_name] = self.generate_random_name()
                return f'{self.variable_mapping[var_name]} ='
            return match.group(0)
        
        code = re.sub(variable_pattern, replace_variable, code)
        
        # 변수 사용 부분도 변경
        for original, obfuscated in self.variable_mapping.items():
            code = re.sub(r'\b' + re.escape(original) + r'\b', obfuscated, code)
        
        return code
    
    def obfuscate_functions(self, code: str) -> str:
        """함수명 난독화"""
        # 함수 정의 패턴
        function_pattern = r'def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\('
        
        def replace_function(match):
            func_name = match.group(1)
            if not func_name.startswith('__'):
                if func_name not in self.function_mapping:
                    self.function_mapping[func_name] = self.generate_random_name()
                return f'def {self.function_mapping[func_name]}('
            return match.group(0)
        
        code = re.sub(function_pattern, replace_function, code)
        
        # 함수 호출 부분도 변경
        for original, obfuscated in self.function_mapping.items():
            code = re.sub(r'\b' + re.escape(original) + r'\s*\(', f'{obfuscated}(', code)
        
        return code
    
    def add_junk_code(self, code: str) -> str:
        """쓰레기 코드 추가"""
        junk_lines = [
            f'{self.generate_random_name()} = {random.randint(1, 100)}',
            f'{self.generate_random_name()} = "{self.generate_random_name()}"',
            f'if False: {self.generate_random_name()} = {random.randint(1, 100)}',
            f'while False: {self.generate_random_name()} = {random.randint(1, 100)}',
            f'for {self.generate_random_name()} in []: pass'
        ]
        
        lines = code.split('\n')
        new_lines = []
        
        for line in lines:
            new_lines.append(line)
            if random.random() < 0.1:  # 10% 확률로 쓰레기 코드 추가
                new_lines.append(random.choice(junk_lines))
        
        return '\n'.join(new_lines)
    
    def encode_code(self, code: str) -> str:
        """코드를 base64로 인코딩하여 실행 코드로 변환"""
        compressed = zlib.compress(code.encode('utf-8'))
        encoded = base64.b64encode(compressed).decode()
        
        decoder_code = f'''
import base64
import zlib
exec(zlib.decompress(base64.b64decode("{encoded}")).decode('utf-8'))
'''
        return decoder_code
    
    def obfuscate(self, code: str, level: int = 1, encode: bool = False) -> str:
        """코드 난독화 메인 함수"""
        print("난독화 시작...")
        
        # 1단계: 기본 정리
        if level >= 1:
            print("1단계: 주석 및 docstring 제거...")
            code = self.remove_comments(code)
            code = self.remove_docstrings(code)
        
        # 2단계: 변수명 난독화
        if level >= 2:
            print("2단계: 변수명 난독화...")
            code = self.obfuscate_variables(code)
        
        # 3단계: 함수명 난독화
        if level >= 3:
            print("3단계: 함수명 난독화...")
            code = self.obfuscate_functions(code)
        
        # 4단계: 문자열 난독화
        if level >= 4:
            print("4단계: 문자열 난독화...")
            code = self.obfuscate_strings(code)
        
        # 5단계: 쓰레기 코드 추가
        if level >= 5:
            print("5단계: 쓰레기 코드 추가...")
            code = self.add_junk_code(code)
        
        # 최종 인코딩
        if encode:
            print("최종 인코딩...")
            code = self.encode_code(code)
        
        print("난독화 완료!")
        return code


def read_file(file_path: str) -> str:
    """파일 읽기"""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        print(f"파일 읽기 오류: {e}")
        return ""


def write_file(file_path: str, content: str) -> bool:
    """파일 쓰기"""
    try:
        os.makedirs(os.path.dirname(file_path), exist_ok=True)
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(content)
        return True
    except Exception as e:
        print(f"파일 쓰기 오류: {e}")
        return False


def main():
    parser = argparse.ArgumentParser(description='Python 코드 난독화 도구')
    parser.add_argument('input_file', help='입력 파일 경로')
    parser.add_argument('-o', '--output', help='출력 파일 경로')
    parser.add_argument('-l', '--level', type=int, default=3, choices=[1, 2, 3, 4, 5], 
                       help='난독화 레벨 (1-5, 기본값: 3)')
    parser.add_argument('-e', '--encode', action='store_true', 
                       help='최종 코드를 base64로 인코딩')
    parser.add_argument('--no-comments', action='store_true', 
                       help='주석 제거')
    
    args = parser.parse_args()
    
    # 파일 읽기
    code = read_file(args.input_file)
    if not code:
        return
    
    # 난독화 실행
    obfuscator = CodeObfuscator()
    obfuscated_code = obfuscator.obfuscate(code, level=args.level, encode=args.encode)
    
    # 출력 파일 경로 설정
    if args.output:
        output_path = args.output
    else:
        base_name = os.path.splitext(args.input_file)[0]
        output_path = f"{base_name}_obfuscated.py"
    
    # 파일 저장
    if write_file(output_path, obfuscated_code):
        print(f"난독화된 코드가 저장되었습니다: {output_path}")
        
        # 원본과 난독화된 코드 크기 비교
        original_size = len(code)
        obfuscated_size = len(obfuscated_code)
        print(f"원본 크기: {original_size} 문자")
        print(f"난독화 크기: {obfuscated_size} 문자")
        print(f"크기 변화: {((obfuscated_size - original_size) / original_size * 100):.1f}%")


if __name__ == "__main__":
    main()

난독화_GUI.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
코드 난독화 GUI 도구
사용자 친화적인 인터페이스로 코드를 난독화합니다.
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import os
import threading
from 코드_난독화_도구 import CodeObfuscator, read_file, write_file


class ObfuscatorGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("코드 난독화 도구")
        self.root.geometry("800x600")
        self.root.resizable(True, True)
        
        # 변수 초기화
        self.input_file_path = tk.StringVar()
        self.output_file_path = tk.StringVar()
        self.obfuscation_level = tk.IntVar(value=3)
        self.encode_code = tk.BooleanVar(value=False)
        self.remove_comments = tk.BooleanVar(value=True)
        
        self.setup_ui()
        
    def setup_ui(self):
        # 메인 프레임
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 그리드 가중치 설정
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(3, weight=1)
        
        # 파일 선택 섹션
        ttk.Label(main_frame, text="입력 파일:").grid(row=0, column=0, sticky=tk.W, pady=5)
        ttk.Entry(main_frame, textvariable=self.input_file_path, width=50).grid(row=0, column=1, sticky=(tk.W, tk.E), padx=5, pady=5)
        ttk.Button(main_frame, text="찾아보기", command=self.browse_input_file).grid(row=0, column=2, padx=5, pady=5)
        
        ttk.Label(main_frame, text="출력 파일:").grid(row=1, column=0, sticky=tk.W, pady=5)
        ttk.Entry(main_frame, textvariable=self.output_file_path, width=50).grid(row=1, column=1, sticky=(tk.W, tk.E), padx=5, pady=5)
        ttk.Button(main_frame, text="찾아보기", command=self.browse_output_file).grid(row=1, column=2, padx=5, pady=5)
        
        # 옵션 섹션
        options_frame = ttk.LabelFrame(main_frame, text="난독화 옵션", padding="10")
        options_frame.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=10)
        options_frame.columnconfigure(1, weight=1)
        
        # 난독화 레벨
        ttk.Label(options_frame, text="난독화 레벨:").grid(row=0, column=0, sticky=tk.W, pady=5)
        level_frame = ttk.Frame(options_frame)
        level_frame.grid(row=0, column=1, sticky=tk.W, pady=5)
        
        levels = [
            ("1 - 기본 (주석 제거)", 1),
            ("2 - 변수명 난독화", 2),
            ("3 - 함수명 난독화", 3),
            ("4 - 문자열 난독화", 4),
            ("5 - 최고 (쓰레기 코드 추가)", 5)
        ]
        
        for i, (text, value) in enumerate(levels):
            ttk.Radiobutton(level_frame, text=text, variable=self.obfuscation_level, 
                           value=value).grid(row=0, column=i, padx=10)
        
        # 추가 옵션
        ttk.Checkbutton(options_frame, text="코드 인코딩 (base64)", 
                       variable=self.encode_code).grid(row=1, column=0, columnspan=2, sticky=tk.W, pady=5)
        ttk.Checkbutton(options_frame, text="주석 제거", 
                       variable=self.remove_comments).grid(row=2, column=0, columnspan=2, sticky=tk.W, pady=5)
        
        # 버튼 섹션
        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=3, column=0, columnspan=3, pady=10)
        
        ttk.Button(button_frame, text="난독화 실행", command=self.run_obfuscation).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="미리보기", command=self.preview_obfuscation).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="초기화", command=self.reset_form).pack(side=tk.LEFT, padx=5)
        
        # 결과 표시 섹션
        result_frame = ttk.LabelFrame(main_frame, text="결과", padding="10")
        result_frame.grid(row=4, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=10)
        result_frame.columnconfigure(0, weight=1)
        result_frame.rowconfigure(0, weight=1)
        
        # 노트북 (탭) 생성
        self.notebook = ttk.Notebook(result_frame)
        self.notebook.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 원본 코드 탭
        original_frame = ttk.Frame(self.notebook)
        self.notebook.add(original_frame, text="원본 코드")
        self.original_text = scrolledtext.ScrolledText(original_frame, wrap=tk.WORD, height=15)
        self.original_text.pack(fill=tk.BOTH, expand=True)
        
        # 난독화된 코드 탭
        obfuscated_frame = ttk.Frame(self.notebook)
        self.notebook.add(obfuscated_frame, text="난독화된 코드")
        self.obfuscated_text = scrolledtext.ScrolledText(obfuscated_frame, wrap=tk.WORD, height=15)
        self.obfuscated_text.pack(fill=tk.BOTH, expand=True)
        
        # 통계 탭
        stats_frame = ttk.Frame(self.notebook)
        self.notebook.add(stats_frame, text="통계")
        self.stats_text = scrolledtext.ScrolledText(stats_frame, wrap=tk.WORD, height=15)
        self.stats_text.pack(fill=tk.BOTH, expand=True)
        
        # 진행 상황 표시
        self.progress_var = tk.StringVar(value="준비됨")
        ttk.Label(main_frame, textvariable=self.progress_var).grid(row=5, column=0, columnspan=3, pady=5)
        
    def browse_input_file(self):
        filename = filedialog.askopenfilename(
            title="입력 파일 선택",
            filetypes=[("Python files", "*.py"), ("All files", "*.*")]
        )
        if filename:
            self.input_file_path.set(filename)
            self.load_original_code()
            
            # 자동으로 출력 파일명 설정
            base_name = os.path.splitext(filename)[0]
            self.output_file_path.set(f"{base_name}_obfuscated.py")
    
    def browse_output_file(self):
        filename = filedialog.asksaveasfilename(
            title="출력 파일 선택",
            defaultextension=".py",
            filetypes=[("Python files", "*.py"), ("All files", "*.*")]
        )
        if filename:
            self.output_file_path.set(filename)
    
    def load_original_code(self):
        file_path = self.input_file_path.get()
        if file_path and os.path.exists(file_path):
            try:
                code = read_file(file_path)
                self.original_text.delete(1.0, tk.END)
                self.original_text.insert(1.0, code)
                self.progress_var.set("원본 코드 로드됨")
            except Exception as e:
                messagebox.showerror("오류", f"파일 읽기 오류: {e}")
    
    def run_obfuscation(self):
        if not self.input_file_path.get():
            messagebox.showwarning("경고", "입력 파일을 선택해주세요.")
            return
        
        if not self.output_file_path.get():
            messagebox.showwarning("경고", "출력 파일을 선택해주세요.")
            return
        
        # 별도 스레드에서 실행
        thread = threading.Thread(target=self._run_obfuscation_thread)
        thread.daemon = True
        thread.start()
    
    def _run_obfuscation_thread(self):
        try:
            self.progress_var.set("난독화 진행 중...")
            self.root.update()
            
            # 원본 코드 읽기
            original_code = read_file(self.input_file_path.get())
            if not original_code:
                messagebox.showerror("오류", "입력 파일을 읽을 수 없습니다.")
                return
            
            # 난독화 실행
            obfuscator = CodeObfuscator()
            obfuscated_code = obfuscator.obfuscate(
                original_code, 
                level=self.obfuscation_level.get(), 
                encode=self.encode_code.get()
            )
            
            # 파일 저장
            if write_file(self.output_file_path.get(), obfuscated_code):
                # 결과 표시
                self.obfuscated_text.delete(1.0, tk.END)
                self.obfuscated_text.insert(1.0, obfuscated_code)
                
                # 통계 계산
                original_size = len(original_code)
                obfuscated_size = len(obfuscated_code)
                size_change = ((obfuscated_size - original_size) / original_size * 100)
                
                stats = f"""난독화 완료!

파일 정보:
- 입력 파일: {self.input_file_path.get()}
- 출력 파일: {self.output_file_path.get()}

크기 정보:
- 원본 크기: {original_size:,} 문자
- 난독화 크기: {obfuscated_size:,} 문자
- 크기 변화: {size_change:+.1f}%

난독화 옵션:
- 레벨: {self.obfuscation_level.get()}
- 인코딩: {'예' if self.encode_code.get() else '아니오'}
- 주석 제거: {'예' if self.remove_comments.get() else '아니오'}

난독화된 파일이 성공적으로 저장되었습니다!
"""
                
                self.stats_text.delete(1.0, tk.END)
                self.stats_text.insert(1.0, stats)
                
                self.notebook.select(2)  # 통계 탭으로 이동
                self.progress_var.set("난독화 완료!")
                
                messagebox.showinfo("완료", "코드 난독화가 완료되었습니다!")
            else:
                messagebox.showerror("오류", "파일 저장에 실패했습니다.")
                
        except Exception as e:
            messagebox.showerror("오류", f"난독화 중 오류가 발생했습니다: {e}")
            self.progress_var.set("오류 발생")
    
    def preview_obfuscation(self):
        if not self.input_file_path.get():
            messagebox.showwarning("경고", "입력 파일을 선택해주세요.")
            return
        
        try:
            self.progress_var.set("미리보기 생성 중...")
            self.root.update()
            
            # 원본 코드 읽기
            original_code = read_file(self.input_file_path.get())
            if not original_code:
                messagebox.showerror("오류", "입력 파일을 읽을 수 없습니다.")
                return
            
            # 난독화 실행 (미리보기용)
            obfuscator = CodeObfuscator()
            obfuscated_code = obfuscator.obfuscate(
                original_code, 
                level=self.obfuscation_level.get(), 
                encode=self.encode_code.get()
            )
            
            # 결과 표시
            self.obfuscated_text.delete(1.0, tk.END)
            self.obfuscated_text.insert(1.0, obfuscated_code)
            
            # 통계 계산
            original_size = len(original_code)
            obfuscated_size = len(obfuscated_code)
            size_change = ((obfuscated_size - original_size) / original_size * 100)
            
            stats = f"""미리보기 통계:

크기 정보:
- 원본 크기: {original_size:,} 문자
- 난독화 크기: {obfuscated_size:,} 문자
- 크기 변화: {size_change:+.1f}%

난독화 옵션:
- 레벨: {self.obfuscation_level.get()}
- 인코딩: {'예' if self.encode_code.get() else '아니오'}
- 주석 제거: {'예' if self.remove_comments.get() else '아니오'}
"""
            
            self.stats_text.delete(1.0, tk.END)
            self.stats_text.insert(1.0, stats)
            
            self.notebook.select(1)  # 난독화된 코드 탭으로 이동
            self.progress_var.set("미리보기 완료")
            
        except Exception as e:
            messagebox.showerror("오류", f"미리보기 생성 중 오류가 발생했습니다: {e}")
            self.progress_var.set("오류 발생")
    
    def reset_form(self):
        self.input_file_path.set("")
        self.output_file_path.set("")
        self.obfuscation_level.set(3)
        self.encode_code.set(False)
        self.remove_comments.set(True)
        
        self.original_text.delete(1.0, tk.END)
        self.obfuscated_text.delete(1.0, tk.END)
        self.stats_text.delete(1.0, tk.END)
        
        self.progress_var.set("준비됨")


def main():
    root = tk.Tk()
    app = ObfuscatorGUI(root)
    root.mainloop()


if __name__ == "__main__":
    main()

2025/08/30

내용이 길어 첨부파일로만 올립니다.

주의사항

0.난독화_GUI.py의 레벨5를 사용하면서 코드 인코딩, 주석 암호화 또는 인코딩 암호화를 사용전 난독화 실행을 한번 실행후 결과를 확인해서 사용해보고 잘될때 코드 인코딩, 주석 암호화 또는 인코딩 암호화를 사용하시기 바랍니다.

python 바탕화면 위치 변경시 os.path.expanduser('~') 안먹힘 해결 방법

공유해드림 — Mon, 18 Aug 2025 00:51:24 +0900

Windows 10 PRO에서 진행하였습니다.

ctypes에 windll로 해결하면 됩니다.

import os
import ctypes
import winreg

def get_desktop_path():
    """Windows 특수 폴더 API를 사용하여 바탕화면 경로 가져오기"""
    try:
        # Windows 특수 폴더 API 사용
        CSIDL_DESKTOP = 0x0000
        SHGFP_TYPE_CURRENT = 0
        
        shell32 = ctypes.windll.shell32
        buffer = ctypes.create_unicode_buffer(260)
        
        if shell32.SHGetFolderPathW(None, CSIDL_DESKTOP, None, SHGFP_TYPE_CURRENT, buffer) == 0:
            return buffer.value
        else:
            # 실패 시 레지스트리에서 확인
            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, 
                                r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders") as key:
                desktop_path = winreg.QueryValueEx(key, "Desktop")[0]
                return desktop_path
    except:
        # 최후의 수단으로 USERPROFILE 사용
        # userprofile = os.environ.get('USERPROFILE', 'C:\\Users\\USER')
        return os.path.join(os.path.expanduser('~'), "Desktop")

만약 windll도 안될시 winreg의 레지스트리 읽어서 가져오면 됩니다.

python3.13.x 잘 사용하던 numpy, openCV가 갑지기 에러 날시 해결 방법

공유해드림 — Wed, 6 Aug 2025 01:07:12 +0900

2025/08/06

1. 제거

일단 아래와 같이 설치 되어 있는 numpy, openCV 관련된 내용 모두 제거

pip uninstall numpy opencv-python opencv-contrib-python opencv-python-headless -y

2. 설치

1. NumPy 설치

pip install numpy==2.3.2

2. OpenCV 설치 (NumPy 2.x 호환 버전)

pip install opencv-python==4.10.0.84

3. pyscreeze 수정(파이썬으로 실행할것)

import os

# pyscreeze 파일 경로
pyscreeze_file = r"D:\2.CODE\Python313\Lib\site-packages\pyscreeze\__init__.py"

# 파일 읽기
with open(pyscreeze_file, 'r', encoding='utf-8') as f:
    content = f.read()

# 문제가 되는 라인 수정
content = content.replace(
    "if not RUNNING_PYTHON_2 and cv2.__version__ < '3':",
    "if not RUNNING_PYTHON_2 and hasattr(cv2, '__version__') and cv2.__version__ < '3':"
)

# 파일에 다시 쓰기
with open(pyscreeze_file, 'w', encoding='utf-8') as f:
    f.write(content)

print("pyscreeze 파일이 수정되었습니다.")

최종 설치된 패키지 버전

NumPy: 2.3.2

opencv-python: 4.10.0.84

pyscreeze: 0.1.30 (수정됨)

주의사항

Python 3.13 환경에서 실행
NumPy 2.x와 호환되는 opencv-python 4.10.0.84 버전 사용
pyscreeze 파일의 cv2.version 호출 부분을 수정해야 함

출처 : Cursor AI IDE(Auto모드)