ugrás a tartalomhoz

sql lekérdezések logolása

Anonymous · 2006. Okt. 4. (Sze), 22.39
Hello!

Valaki meg tudná nekem mondani, hogy hogy lehet SQL lekérdezéseket adatbázisba logolni anélkül, hogy alkérésként értelmezné a mysql?
Például, ha egy input-mezőből jön befele egy adat, még ellenőrzés után is maradhat benne olyan adat, amit az sql (később, az eredeti lekérdezésbe beszúrva) alkérésként értelmezhet, és így kész is a gyönyörű sql-injection. Keressem végig a szövegben az összes mysql-kulcsszót?
nazgul[dot]mail[at]freemail.hu
‹ information_schema mysql tábla átalakítása utf8-osra ›
 ■
1

re

toxin · 2006. Okt. 4. (Sze), 22.56
elösször művelődés
http://shiflett.org/articles/security-corner-apr2004

másodszorra, keresés egy erre készült létező class után, és használása
http://cyberai.users.phpclasses.org/browse/package/2189.html

üdv t
2

megnéztem

Anonymous · 2006. Okt. 4. (Sze), 23.24
Köszönöm a gyors választ!
Sajnos nem lettem okosabb. Régóta foglalkozok az sql-injection kivédésével, megvannak a saját függvényeim erre, de hogy nézne ki, hogy kiszűröm az ártó kódot és adatb.-be logolom, ami kb. ugyanolyan, mintha ellenőrzés nélkül elküldtem volna az sql-nek...
A class nem az sql kódot szűri, hanem a html/php/js kódot. Nekem olyan függvényre/osztályra lenne szükségem, ami az sql kulcsszavakat szúrja ki egy sztringben.
3

...

Anonymous · 2006. Okt. 4. (Sze), 23.26
Egyébként SQL-re, meg gyanús bejövő adatokra eddig fájlba logolást használtam, ami meg is felelt, csak ugye mennyival szebb lenne, ha egy felületen logolhatnék...
18

De jó lenne

Anonymous · 2006. Okt. 6. (P), 08.48
Valóban jó lenne, ha a támadó talált egy biztonsági lukat az adatbázis felé és tud törölni, hogy akkor egyből törölheti a logot is, ami elárulhatná... :)
4

XSS vs SQL injection

Hodicska Gergely · 2006. Okt. 4. (Sze), 23.46
http://cyberai.users.phpclasses.org/browse/package/2189.html

Ne keverd össze az XSS-t és az SQL injectiont. Az ajánlott osztály az előbbi elleni védekezésre szolgál, és noha "input"-ot védjük, mégis tipikusan megjelenítéskor kell rá nagyon odafigyelni, mert az input az elég sokrétű lehet.

Eredeti kérdésre: simán a mysql_real_escape_string milyért ne lenne jó erre a célra is?


Felhő
5

hát?

Anonymous · 2006. Okt. 5. (Cs), 00.05
A mysql_real_escape_string olyan jeleket szedne le, amit én alapból át sem engedek a form ellenőrzésén. Tudom, hogy mondjuk aposztróf nélkül már alapból nem igazán lehet egy sql-injectiont véghezvinni, de én félek a sima szöveges injectionoktok lehetőségétől (pl valaki beszúr egy 'drop table users'-t egy alkérésként)
6

egy tipp

Anonymous · 2006. Okt. 5. (Cs), 00.44
szia,
Én csináltam már hasonlót.
1. Az adatbázis kapcsolódás után SHOW TABLES -al kiolvasom a táblaneveket, egy regex-el átalakítom azokat így: 'users' -> 'uxsers'. Ezeket beteszem egy tömbbe.
2. Szintén tömbbe teszem a kritikusnak tartott sql parancsokat: drop, delete, truncate... normál és átalakított formában is.
3. Minden queryt egy függvényben hajtok végre. Ebben egyszerűen lecserélem a 'users' szövegrészeket a módosított formára. Így kapja meg az sql, ha valamilyen módon mégis átjátsszák az előtte levő védelmeket (pl. \' ) akkor is pl. ezt kapja az sql: '... dxrop uxsers ...'
4. Kiolvasást szintén fv-en keresztül végzek, ahol megcsinálom a visszaalakítást - így az oldalon már az eredeti szöveg lesz (pl. egy fórum hozzászólásnál, ahol egy beküldött kód tartalmazza a fentebb példázott stringet.
Mivel az adatbáziskezelés külön saját függvénytáron keresztül történik, az egész nem olyan macerás, mint elsőre tűnik.
7

jaja

Anonymous · 2006. Okt. 5. (Cs), 01.19
Én is gondoltam már hasonlóra, de a plusz időköltség miatt bele sem kezdtem. Aránylag sok lekérdezés van a rendszeremben, nem esne jól mégegy réteg a futási időknek.
Nekem speciál még nem sikerült bizonyítani, hogy alapvető karaktererkkel ([:space:]a-zA-Z0-9.,:@_-éáőúöüóűíÉÁŐÚÖÜÓŰÍ) lehet-e sql-injekciót végrehajtani.
Szerintem az aposztróf hiánya például alaposan megcsappantja a lehetőségeket.
Majd rátesztelek, ha lesz egy kis időm...
8

nemtom...

Anonymous · 2006. Okt. 5. (Cs), 06.19
Nem tudom, nekem kicsit mondvacsinált és paranoid dolognak tűnik a hozzáálásod, ami egésszésges szinten nem baj, sőt(!), de nálad ez már kicsit túllőtt a célon :)
Másolhatnál ide majd néhány félelmetes és gonosz, időn és téren túl lévő, SQL-be oltott cuccot, ami eszképelés és a fent írt ellenőrzési módszerek futtatása után még benne maradhat a kódban. Kíváncsian várom. Köszi!
16

hát mégse...

Anonymous · 2006. Okt. 6. (P), 07.49
Mégsem érkezik egyetlen félelmetes SQL injekciós példa, amit a szokásos módszerek és függvények és gondos tervezés nem irt ki?
Annyit hallottam már erről, de soha nem láttam még egyetlen működőt sem, amivel ártani lehetett volna. Megesz a kíváncsiság, de komolyan. :)
19

Cikk

Anonymous · 2006. Okt. 6. (P), 08.50
Olvassátok el a "védezekést a frontvonalon" cikket. Vannak olyan esetek, amikor ez elegendő, akkor ki kell szűrni minden egyebet. Van, amikor nem. De gondoljatok arra is, hogy mi van, ha pl. egy lengyel szeretne regisztrálni az oldalatokra és nem tud, mert visszadobjátok a nevét. Szerintem, enyhén meg lenne bántva.
12

nem tanács, csak ötlet

Anonymous · 2006. Okt. 5. (Cs), 12.14
Ha aránylag sok lekérdezásed van, akkor bizonyára összetett a rendszered. Mi van, ha egyszer majd át akarsz állni másik adatbázis kezelőre (mysql > postgre)? Újraírod az egészet, pedig csak egy réteget (nálam ez egy külön fájlban lévő függvénytár) kellene cserélni.
aposztróf hiánya alaposan megcsappantja a lehetőségeket
Ez így van. A leírt módszer segíthet előre nem látott, vagy a későbbi fejlesztés során bekerülő bug semlegesítésében.
A magam részéről nem tanácsot, csak ötletet akartam adni. Tetszés szerint megfogadható/elvethető - ízlés dolga.
9

nem kevertem új fícsőr az input filter-ben

toxin · 2006. Okt. 5. (Cs), 07.46
Check out the new SQL Injection feature..

üdv t :)
11

ok, nem derült ki

Hodicska Gergely · 2006. Okt. 5. (Cs), 10.58
Ezzel együtt SZVSZ hibás a megközelítése és a megvalósítása is az osztálynak többszörösen is:
o ideológia: szerintem hibás az a módszer, hogy a bejövő inputot egyszerűen megváltoztatjuk, és utána úgy használjuk. Ha nem jó az input, akkor dobjuk vissza a felhasználónak, jelezzük egyértelműen a hibát, és majd ő eldönti, hogy mit is szeretne (a kedvére persze lehet tenni, gombnyomásra szűrjük a HTML tageket vagy bármi)
o programozás technika: az általános input filter funkcióban ott van egy tök speciális, csak MySQL esetén működő escapelés.
o megvalósítás: kisebbik baj, hogy fogalma sincs róla, hogy mi az, hogy statikus metódus (példában használja, közben a függvényben ott a $this kulcsszó), de az már nagyon gáz, hogy magát az escapelő függvényeket rosszul használja, tehát épp csak a feladatát nem látja el.

Persze mindenki azt használ, amit csak szeretne. :)


Felhő
13

én

toxin · 2006. Okt. 5. (Cs), 12.45
pear::DataObject-et vagy ADOdb Active Record-ot , vagy max pear::DB -t de mindegyikben automata az escapel-és :))

http://shiflett.org/articles/security-corner-apr2004 -t viszont elolvastam, ill. az (IN)SECURE-ban is ISSUE 1.6 (March 2006) volt egy cikk (PHP and SQL security today), azt is
http://www.insecuremag.com/archive.html

üdv t
14

statkus metódus miaz

toxin · 2006. Okt. 5. (Cs), 14.03
kis szünet, munkában :)

statikus attrib-ot ismerem pear-ből, statikus metódust meg js-ből :)

első ugye ilyesmi

<?php

function &staticValue($class, $var){
    static $properties;
    return $properties[$class][$var];
}

$fooClass = new stdClass();
$fooVar = &staticValue('fooClass','fooVar');
$fooVar = 'booo';
$foovar = 'eztmárnemállítjabe';

echo staticValue('fooClass','fooVar');
?>

kiírja booo
szépen lesz egy statikus attrib az osztályban

javascriptben, meg mittmén

function myClassFoo(name) {
       this.name = name
}

myClassFoo.writeMyName = function(){
        console.log(new Date().getYear());
}
    
new myClassFoo('cuki vagyok');
myClassFoo.writeMyName();
szépen lehet statikus metódust gyártani, de php-ban micsoda? :) kicsit kapkodok máma lehet tudom, csakmost nemugrik be (php-ban nagyon rég class-oztam komolyabban 1-2 hónapja) :S :)

üdv t

ja vagy a Scope Resolution Operator -ra tesztik gondolni :) ( http://www.php.net/manual/en/keyword.paamayim-nekudotayim.php ) magyarán a példányosítás nélküli class-okra ? [think]
15

re: statkus metódus miaz

Hodicska Gergely · 2006. Okt. 6. (P), 02.06
első ugye ilyesmi....PHP példa

Mit szerettél volna elérni ezzel a példával?

szépen lesz egy statikus attrib az osztályban

Nyomj rá egy var_dumpot! ;)

A statikus metódus (a statikus tagváltozóhoz hasonlóan) ideológiailag abban különbözik egy mezitlábas metódustól, hogy egy olyan viselkedést valósít meg, ami nem egy konkrét példányhoz tartozik, hanem magához az osztályhoz. Tipikus könyv példa, hogy szeretnénk nyilvántartani, hogy adott osztályból hány példányt hozunk létre. Technikailag ez azt jelenti, hogy a statikus metódusban nem szerepelhet a $this kulcsszó. PHP4-ben nincs kifejezetten statikus metódus (PHP5-ben már ott a static kulcsszó), vagy attribútum. Itt egy metódus akkor tekinthető statikusnak, ha nem szerepel benne a $this, és ilyenkor lehet az Általad is említett :: operátorral meghívni. Statikus attribútumot pedig csak trükközéssel lehet elérni PHP4-ben:
<?php
class foo
{
	function staticValue($name, $value = null)
	{
		static $values = array();
		if (func_num_args() == 2) {
			$values[$name] = $value;
		} else {
			if (array_key_exists($name, $values)) {
				return $values[$name];
			} else {
				return null;
			}
		}
	}
}

$foo1 = new foo();
$foo2 = new foo();

$foo1->staticValue('bar', 'baz1');
$foo2->staticValue('bar', 'baz2');
var_dump($foo1->staticValue('bar'));
foo::staticValue('bar', 'baz3');
var_dump($foo1->staticValue('bar'));
?>
Látható, hogy bármelyik példányon, vagy osztályon keresztül erjük el a "statikus tagváltozót", annak értéke a többi példányban is megváltozik, tehát osztály szinten csak egyetlen létezik belőle.

szépen lehet statikus metódust gyártani....JS példád

Itt szintén nem értem, hogy mit szerettél volna bemutatni a példával. JavaScript esetén nem is igazán van értelme statikus metódusról beszélni, itt a this-t nem használó függvények egy osztályon belül kb. csak azért vannak, hogy egy namespace-be legyenek zárva, mint mondjuk a prototype Event.observe() függvénye, lehetne nyugodtan Event_observe is.


Felhő
17

azt

toxin · 2006. Okt. 6. (P), 08.43
hogy nemtudom miaz a statikus metódus, ellenben milyen okos vagyok :)))

Nyomj rá egy var_dumpot! ;)

mire nyomjak vardumpot ? (nem kötözködök most már érdekel :) ) megkerestem pear-ben is
http://pear.php.net/manual/hu/core.pear.pear.getstaticproperty.php
erről van szó, ott a példa


<?php

require_once 'PEAR.php';

class myClass {

function setValue( $set) 
{
 $foo = &PEAR::getStaticProperty('myClass', "foo");
 $foo = $set;
}

function view()
{
 print PEAR::getStaticProperty('myClass', "foo");
}

}

myClass::setValue('value = foo');
myClass::view();
?>
ill. pear.php-ban
 // }}}
    // {{{ getStaticProperty()

    /**
    * If you have a class that's mostly/entirely static, and you need static
    * properties, you can use this method to simulate them. Eg. in your method(s)
    * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar');
    * You MUST use a reference, or they will not persist!
    *
    * @access public
    * @param  string $class  The calling classname, to prevent clashes
    * @param  string $var    The variable to retrieve.
    * @return mixed   A reference to the variable. If not set it will be
    *                 auto initialised to NULL.
    */
    function &getStaticProperty($class, $var)
    {
        static $properties;
        return $properties[$class][$var];
    }
csak bepötyögni gyorsabb volt, saját példát

üdv t
20

re: azt

Hodicska Gergely · 2006. Okt. 6. (P), 11.06
hogy nemtudom miaz a statikus metódus, ellenben milyen okos vagyok :)))
hát ja ;)

mire nyomjak vardumpot?

Arra akartam utalni, hogy a példádban a statikus változó nem része az osztálynak, ezért nincs is túl sok értelme, simán egy globális tömbe is pakolhatnád abban a megközelítésben.

(nem kötözködök most már érdekel :) )

Nem is annak fogtam föl, látom, hogy Téged érdekelnek a felszín alatti dolgok is.

megkerestem pear-ben is
http://pear.php.net/manual/hu/core.pear.pear.getstaticproperty.php
erről van szó, ott a példa

Hát ebből is az derül ki, hogy a PEAR-ben a sok értékes dolog mellett van sok olyan, ami nem az. Kb. ugyanez a baja a PEAR mgközelítésnek is, mint a Te példádnak, az osztályon kívül vannak tárolva a "statikus" változók.

Ha megnézed az én példámat, akkor a következő példából látni fogod a megközelítés beli különbséget. A statikus változók ténylegesen az adott osztályhoz fognak tartozni, egy adott osztályból nem éred el egy másik osztály statikus tagváltozóját. Plusz szerintem az általam nyújtott interface is szebb, mint a PEAR-é, azt hiszem, hogy be is fogom küldeni nekik ezt a megvalósítást.
<?php
	class base
	{
		function staticProperty($name, $value = null)
		{
			static $properties = array();
			if (func_num_args() == 2) {
				$properties[$name] = $value;
			} else {
				if (array_key_exists($name, $properties)) {
					return $properties[$name];
				} else {
					return null;
				}
				// the above 5 line code coulde be
				// return @$properties[$name];
			}
		}
	}

	class foo extends base
	{
	}

	class bar extends base
	{
	}


	foo::staticProperty('foo', 'foo');
	var_dump(bar::staticProperty('foo'));
	bar::staticProperty('foo', 'bar');
	var_dump(bar::staticProperty('foo'));

	$foo = new foo();
	var_dump($foo->staticProperty('foo'));
	$bar = new bar();
	var_dump($bar->staticProperty('foo'));
?>
Felhő
21

kössz

toxin · 2006. Okt. 6. (P), 13.34
a kimeritő válasz, igazából tényleg érdeklődés szintjén vagyok, vitatkozni az általad közölt megoldásról nem is mernék :) , az egésszel én pear::DB_DATAOBJECT leírásában találkoztam, ott néztem meg közelebről

http://pear.php.net/manual/en/package.database.db-dataobject.intro-purpose.php
alult a Example 33-4. At last some real DataObject Code.. -nál a konfigurációs adatok kerülnek be a fenti módszerrel statikus attrib-nak

// this  the code used to load and store DataObjects Configuration.
    $options = &PEAR::getStaticProperty('DB_DataObject','options');
   
    // the simple examples use parse_ini_file, which is fast and efficient.
    // however you could as easily use wddx, xml or your own configuration array.
    $config = parse_ini_file('example.ini',TRUE);
   
    // because PEAR::getstaticProperty was called with and & (get by reference)
    // this will actually set the variable inside that method (a quasi static variable)
    $options = $config['DB_DataObject'];


a pear-en lévő cuccokat se merem krtitzálni, de ha benn van a base class-ban , háát [think]

üdv t
22

azért mert PEAR...

Hodicska Gergely · 2006. Okt. 6. (P), 15.24
a pear-en lévő cuccokat se merem krtitzálni, de ha benn van a base class-ban , háát [think]

Azért mert a PEAR-ben van egy megoldás, az nem feltétlenül jelenti azt, hogy az a legjobb megoldás. Ha megnézed annak a kódnak a használati eseteit, akkor az enyém biztosítja azt a funkcionalitást (egyszerűbben), plusz a ebben a helyén vannak a dolgok (tisztább, szárazabb érzés). Bedobtam PEAR dev listára is, ha van vele valami gond, akkor ki fog derülni.


Felhő
23

PEAR válasz

Hodicska Gergely · 2006. Okt. 6. (P), 16.46
http://marc.theaimsgroup.com/?l=pear-dev&m=116014574717586&w=2


Felhő
24

ahha, de nem volt meglepő

toxin · 2006. Okt. 6. (P), 18.57
pear-nek már kialakult függőségi hálója van, (akit érdekel, kukk meg: php fejl. felsőfokon 227. oldal alját itt írnak erről : A csatolás csökkentése-nél ) 2-es pont is érthető

üdv t

ui: bocsánat hogy csak 'little discussion'-ra tellik tőlem :) (de ebben az évben a javscript-re ill a prototype-ra izgultam rá, és holnaptól a YUI-ra:)) )
25

re: ahha, de nem volt meglepő

Hodicska Gergely · 2006. Okt. 6. (P), 21.09
Nem is gondoltam volna, hogy hirtelen lecserélnek egy ilyen alap osztályt, csak úgy tűnt, hogy kicsit kétkedsz a kód helyességében, ezért gondoltam, hogy egy PEAR alap ember szájából már hietőbbnek tűnik. A 2-es ponttal speciel pont nem értek egyet, mert minimális változtatással (vagy használati szabály bevezetése, mint ahogy most is van ilyen, hisz az megállapodás, hogy az osztály nevét használják "kulcsként") meg lehetett volna oldani, hogy ne kelljen ezért a funkcionalitásért az alap osztályból származtatni az osztályokat. Tehát kevés esetben ugyanott vagyunk, míg a legtöbb esetben jobban járunk.


Felhő

u.i.: YUI nagyon jónak, és használhatónak tűnik, pl. eseménykezelése jóval fejlettebb, mint a prototype-é. Érdekes tapasztalat lesz, hogy hogyan lehet/érdemes a kettőt együtt használni.
10

natív tipúsként használni

zsepi · 2006. Okt. 5. (Cs), 08.35
prepared statement? bind variable? tárolt eljárás?