FireStats error : FireStats: Unknown commit strategy Skip to content

Google!

Archive

Category: Net-security-devel

SweMobile – En svensk SMS-tjänst för statusuppdateringar på Facebook

Applikationen SweMobile som ligger uppe på prov, finns på http://dev.tornevall.net/facebook/mobile/ som en stand-alone-sida eller http://apps.facebook.com/swemobile/ om man vill ha Facebook-designen inkluderad i gränssnittet.

Vad är ”SweMobile Gateway”?

Tjänsten SweMobile byggdes för att det inte funnits någon möjlighet att ansluta svenska mobiltelefoner till Facebook. Jag pratar naturligtvis om den funktion som ligger på adressen http://www.facebook.com/mobile/?settings där man registrerar sig för ”Facebook SMS”. Man kan välja operatör i princip för alla länder – utom Sverige av någon märklig anledning. Andra mobila tjänster fungerar däremot, men då måste mobiltelefonerna naturligtvis även ha stöd för det, vilket äldre modeller högst sannolikt inte har. I synnerhet inte de mobiler som levereras utan surfmöjligheter.

Hur fungerar tjänsten? Är jag anonym?

I stort sett, ja. SweMobile lagrar nästan ingen information alls om användaren – bara den information som krävs för att kopplingen skall fungera. Inga namn, personnummer eller dylikt sparas alltså i någon databas och eventuella namnuppgifter som finns på webbsidan kommer direkt från Facebook.

Inloggning

För att tjänsten skall fungera måste man till att börja med logga in. Vid första inloggningen är applikationen dock oanvändbar. För att SweMobile skall kunna ta emot dina SMS och logga dem som en statusuppdatering på facebook, måste användaren själv godkänna att det är okej. Detta sker alltså inte direkt. Väl inloggad så kommer den möjligheten däremot att finnas. Om aktivering från användarens sida inte sker, kommer denne inte heller att kunna använda applikationen.

Aktivering

Aktivering sker genom ”Aktivera”-knappen i applikationen. I det ögonblick som aktivering av SweMobile sker, så sparas också Facebooks användar-ID undan (och endast detta), flaggad som ”aktiverad”. I samma stund som detta görs, så kan man också testa om allting fungerar som det skall, genom att simulera ett SMS-utskick genom knappen ”testa publiceringsfunktionen”. Detta innebär att applikationen själv postar ett inlägg från dig till din status.

Koppling av mobilnummer

Applikationen är dock inte aktiverad till fullo ännu. Först måste du koppla ett mobilnummer till det användarid som facebook tillhandahåller. Detta gör du genom att klicka på ”Aktivera en mobiltelefon”. När du klickar på länken för att aktivera en mobiltelefon skapas en kod på fem bokstäver. Denna kod måste du skicka, via SMS, till SweMobile (se  nummer och instruktioner nedan). När detta är gjort, så kommer applikationen att markera att just ditt användarid använder det mobilnummer du skickade SMSet ifrån. Det finns ingen begränsning på hur många mobiler du kan aktivera, dock kan det bara vara unika nummer; att aktivera ett mobilnummer på två användare fungerar alltså inte. Själva aktiveringen görs genom att skicka meddelandet ”FACE REG AKTIVERINGSKOD” till 0702747703. Har du exempelvis fått koden ABCDE så skickar du alltså ”FACE REG ABCDE” till 0702747703.

Statusuppdateringar / Facebookloggen

När aktiveringen har gjorts kan du börja skicka SMS till din status på facebook. Detta gör du genom att du helt sonika, återigen till 0702747703, skickar meddelandet FACE, men denna gången med den text du vill skriva. Exempel: ”FACE sitter just nu i tältet och dricker bärs”.


Läs även andra bloggares åsikter om , , , , , , , , , , ,

Jag satt och funderade på om det fanns någon applikation som kunde byta namn på alla ”TITELs03e09.avi”-filer på disken… Dvs, i princip byta namn på videoklipp vars filtitel innehåller säsongsnummer och avsnitt, enligt följande princip:

Efter hanteringen skall de alltså se ut så här:

För jag bryr mig faktiskt inte vilket format klippen är i, eller vilken L33T Sc3N3-dumpare som konverterat klippen.

Men vad skall man söka efter? ”Avi episode renamer”? Ja, varför inte? Jag hittade ju faktiskt ett program som fixar det, här, men jag vet ju så klart inte hur pålitliga programmen är. Och jag vill helst ha filnamnen i sin kortaste form. Så jag gav mig på ett försök att fixa det med lite php och regular expressions. Så här gick det med första försöket:

Konverteringsdelen?

// Extract the file-extension so we keeps get same filename
$getextension = explode(”.”, $f);
$extension = $getextension[sizeof($getextension)-1];
// Try a regexp here
$fil = preg_replace(”/(.*?)s([0-9]+.*?)e([0-9]+.*?).(.*?)$/i”, ’s$2e$3′, $f) . ”.” . $extension;

Källkoden? Här!

”Force”-kommandot finns där med ett enda syfte: Att försäkra användaren att rätt filer kommer konverteras och att de kommer konverteras till rätt format.

Detta gjorde ju livet lite lättare i all organisering…!

I like!

#!/bin/sh

procname=$1
nothing=”"

if [ "$procname" ]
then
ps aux | grep -i $1 | grep -v grep | awk ‘{ printf ”kill -9 ” $2 ”\n”}’
ps aux | grep -i $1 | grep -v grep | awk ‘{system(”kill -9 ” $2)}’
exit
fi

echo ”Use: $0 <proc>”

Jag blev nyligen uppmärksammad på att säkerheten för bloggpalatset.se kunde förbättras en liten aning. Plötsligt från ingenstans önskade jag att ftp-användare bara skulle kunna logga in från den lokala servern som alla bloggar är inställda att anropa. Detta av den enkla anledningen att alla ftp-lösenord finns synliga ifrån blogg-admin om man bara tänker till lite. Så hur begränsar man en FTP-server på vilken vars användare är virtuella och där alla användaruppgifter inte hämtas från unix-passwd – så att de plötsligt inte får för sig att lägga upp grejer som vi definitivt inte vill ha in i systemet?

Jo, det är faktiskt väldigt enkelt!

Istället för

SQLUserInfo     ftpuser userid passwd uid gid homedir shell

Så gör man loginkontrollen så här:

SQLUserInfo     custom:/getusers
SQLNamedQuery getusers SELECT "userid,passwd,uid,gid,homedir,shell FROM
           ftpuser WHERE userid = '%U' AND '%a' = '127.0.0.1'"

%a står för ipaddress (likt apaches logsystem alltså, så använder man såna parametrar med fördel här). I det här fallet kontrolleras alla användare helt enkelt om användaren ansluter från 127.0.0.1 eller någon annan adress. Om ipadressen är någon annan än 127.0.0.1 så kommer alltså proftpd att säga ”nopp, den här användaren finns inte”.

Jag gillar proftpd – hittills har den kunna göra precis allt jag har viljat att den skulle göra. Så med tanke på denna anpassningen, så tror jag att jag stannar kvar hos den servern en stund till.


Läs även andra bloggares åsikter om , ,

The crash course

  • Lägg till PHP -mappen i PATH-variabeln (Environment variables)
  • Börja lämpligtvis med att hämta PHP (I skrivande stund används php-5.2.13-Win32.zip).
  • Packa upp zipfilen i exempelvis C:\PHP
  • Starta IIS och välj egenskaper för webtjänsten som skall ha PHP.
  • Gå till fliken ISAPI Filters.
  • Lägg till PHP och ange C:\PHP\php5isapi.dll som ”Executable”. Se även till att den filen finns i PHP-mappen.
  • Gå till fliken Home directory, klicka på configuration och lägg till Executable: C:\PHP\php5isapi.dll och Extension: PHP
  • Kontrollera Home-fliken och se till att script kan köras
  • Acceptera inställningarna och klicka OK
  • Ändra php.ini så att extension_dir pekar mot C:\PHP\ext istället för ./
  • Sätt även cgi.force_redirect = 0
  • Starta om IIS
  • Gå in i IIS igen och sök dig fram till Web Service Extensions.
  • Tillåt ”All unkown ISAPI extensions”

*poof*

Vad ska man med installers till, när man kan göra det manuellt – och samtidigt därmed får en överblick på vad man precis har gjort?

Dessa stegen fungerar förresten med den IIS 6-server jag provade installera mot. Det tog en bra stund innan jag fattade varför jag fick 404-fel överallt. Sista punkten, med rättigheter, är framför allt viktig att slå på om man skall slippa just detta.

Funderar på att släppa Tornevalls egna PHP-motor och Server-övervakning-by-IRC-motorn… I någon form. Kanske. Eftersom det är ett lättanpassat koncept. Osv. Det jobbiga blir att filtrera bort all ”grejer som definitivt inte är bra att släppa”-kod som man lagt till i klasserna av ren lathet. Skall nog fundera lite till.

Det var ett tag sedan jag skrev om mer-trafik.se och bloggfusk, då jag menade att det var ganska lätt att fuska med mer-trafik.se. Nu är det kopiöst onödigt att fuska eftersom man då missar att det faktiskt finns riktigt intressanta bloggare där, som kan vara värda att följa och mer-trafik uppfyller ett väldigt viktigt syfte med sin funktion. Framför allt är den enkel att använda, poängsystemet är konkret och okomplicerat! Man får heller inte prestationsångest när man använder mer-trafik (vilket därmed ger dom högsta poäng som bloggbooster).

Nyligen uppmärksammades jag återigen, efter ett långt uppehåll, på att även bloggtrafik.nu finns tillgänglig för den som är intresserad. Bloggtrafik baseras på liknande system som mer-trafik gör, där man får poäng för varje blogg man besöker. Deras anti-fusk-system ser lite annorlunda ut och på ett sätt är det en säkrare variant, då de använder captcha för att undvika att folk gör script som gör att de själva slipper plocka poängen. Men captchan såg väldigt enkel ut och jag slog vad med mig själv om att den kan knäckas med väldigt enkla medel, på grund av bland annat utformningen med rakt uppställda siffror. Nyfiken som man är, så var man så klart tvungen att ta reda på vilken styrka denna captcha hade.

Det krävs naturligtvis mer än bara en captcha-decrypter för att fuska med sånt här, något jag varken tänker gå in på här eller prova själv. Jag kunde dock bekräfta ganska fort, att man med hjälp av endast ImageMagick och Tesseract-OCR (ett OCR-läsningsprojekt som finns på google) kan läsa av siffrorna på bilderna. Följande fyra bilder användes (testet jag gjorde var inte särskilt omfattande och det var generellt sett nyfikenheten som drev mig att prova), tre av dessa kunde relativt enkelt tolkas av programmen:




Resultatet blev, som följer och som synes inte helt perfekt, men tillräckligt nära en bitter sanning – inte ens bildverifiering är ett bra skydd:


Läs även andra bloggares åsikter om , , ,

Jag fick en riktig utmaning när jag försökte återskapa en gammal websida på nytt, som skulle baseras på PHP och en IIS-anslutning. Servern var i princip identisk med den gamla som kördes på en Windows 2003-maskin, så när som på en liten detalj: På den gamla servern accepterade SQL-servern anrop via mssql_connect. På den nya servern vägrade den detta, av hittills totalt okänd anledning. Det här gjorde mig naturligtvis upprörd, eftersom jag mer eller mindre började känna av en egen deadline komma närmare. Problemet har gäckat mig i flera veckor och basen har sedan sist varit MSSQL Express 2005, som ju fungerade perfekt.

Häromdagen fick jag ett samtal. Flera databaser hade nu flyttats över till den nya webservern och med viss stolthet förklarades att ASP-anropen minsann fungerade klockrent. Inga problem, osv. Det gjorde mig ännu mer frustrerad, varför vägrar plötsligt MSSQL att ta emot samtal från PHP? Den som det visste. ASP-anropen inspirerade mig dock. Detta kanske kunde användas på något bra sätt genom PHP-koden. Och visst är det så, som alltid! Så jag började bygga upp nya anrop som baserades på den ”nya” lösningen, med NO-DSN. För säkerhetsskull lät jag dock det gamla stödet finnas kvar!

if (!$this->ado)
{
	if (!$port)
	{
		$this->tdb = mssql_connect($server, $user, $pass) or $fail = true;
	}
	else
	{
		$this->tdb = mssql_connect("$server:$port", $user, $pass) or $fail = true;
	}
}
// Fallback!
if ($fail || $this->ado)
{
	$conn = new COM ("ADODB.Connection") or die("Cannot start ADO");
	$this->tdb->conn = $conn;		// Fake this
		/* We don't want to use the integrated stuff here, so skip it. */
	//Integrated Security=SSPI;
	$connStr = "Provider=SQLOLEDB.1;UID=" . $user . ";PWD=" . $pass . ";Persist Security Info=False;DATABASE=X;Initial Catalog=X;SERVER=X;Data Source=X";
	$this->tdb->conn->open($connStr); //Open the connection to the database
}

Den här lilla lösningen kräver förstås att man gör ytterligare modifikationer i query-anropen, eftersom de skiljer sig en aning åt, trots att det är samma plattform vi pratar med. Eftersom vi dessutom vill ha ut alla frågor som en array i formatet $array[columnname] = $value, så får speciella funktionsanrop ta hand om utdatat.

// Query
$tSQL = $this->tdb->conn->execute($query);
$returnthis = $this->fetch($tSQL);
[...]
// Funktion
if (!$this->tdb->conn)
{
	return mssql_fetch_array($Array);
}
else
{
	// More data to get?
	if (!$Array->EOF)
	{
		$num_columns = $Array->Fields->Count();
		for ($i=0; $i < $num_columns; $i++)
		{
			$nme = $Array->Fields($i)->name;
			$fld[$nme] = $Array->Fields($i)->value;
		}
		// Movenext should be here, not in the programmers area.
		$Array->MoveNext();
	}
	return $fld;
}

Och därmed, så har vi piskat upp Microsofts bedrövligt självinkompatibla system IGEN! Troligtvis kommer jag inom kort för TorneEngines räkning se till att källkoden ovan inkluderas för att stödja både PHP-mssql-built-in-calls, PHP-mssql-odbc, PHP-mssql-ado-nodsn samt faktiskt även PHP-db2-odbc ala Movex-språk. The more the better…


Läs även andra bloggares åsikter om , , , , , , ,

Tornevall Presents RSSFind 1.0.0

A script that scans a single webpage for possible RSS-feeds. Howto? It’s in the comments!


<?php

// #############################################################################
/**
*
* GETRSS v1.0.0 - Scan a webpage for RSS-links.
*
* Requirements:
*
* 1: The script uses MagpieRSS to parse URLS found by scanner [http://magpierss.sourceforge.net/]
* 2: curl (since file_get_content sometimes fail)
*
* Removed from script: All $tornevall-calls, so we don't have to distribute TorneEngine.
*
* Known problems:
*
* Trying to download data from nattstad.se may make this script act weird.
*
* Usage:
*
* First: Make sure you have an include or require_once for MagpieRSS so fetch_rss works.
*
* @param    string        URL to analyze
* @param    int/bool    Halfway Debugging
*                True/False/Int, Default = False
*                1 = Verbose (Also known as true)
*                2 = More verbose
*
* @return    array        Returns urls found with valid links
*
* Example:
*
*    $rsslinks = getrss($theurl);
*    if (is_array($rsslinks)) {$rsslink = array_pop($rsslinks);}
*
*/
function getrss($url ''$showaction false)
{
    
//global $tornevall;

    // Some extensions to ignore in the content
    $ignore = array("jpg""png""gif""css""bmp""tar""zip""rar""js");
    
$feedcontent = array("rss""feed");

    $breakonfirst true;
    
$urls = array();

    // Compile a base href. Not foolproof but better than nothing
    
$u explode("/"$url);
    foreach (
$u as $finddom)
    {
        if (
$usename) {$usepath .= $finddom "/";}
        if (
preg_match("[^http]"$finddom) && !$urltype) {$urltype $finddom;}
        
//if (long2ip(ip2long($tornevall->resolve($finddom))) && !$usename)
        
if (long2ip(ip2long(gethostbyname($finddom))) && !$usename)
        {
            
$usename $finddom;
        }
    }
    if (!
$urltype) {$urltype "http:";}
    
$usepath preg_replace("[\/$]"''$usepath);
    if (
$usepath) {$baseurl $usename "/" $usepath;} else {$baseurl $url;}
    if (!
preg_match("/^http/i"$baseurl)) {$baseurl $urltype "//" $baseurl;}

    // Save time by testing the main url first! It may be a rsslink
    //$testxml = $tornevall->www->get($url);
    
$testxml rss_getcontent($baseurl);

    if ((preg_match("/xml version/"$testxml) || preg_match("/rss version/"$testxml)) && !preg_match("/comment/i"$url))
    {
        
$rssdata = @fetch_rss($baseurl);
        
// Ok, if we find items here, this may be the main url. Return that!
        
if (sizeof($rssdata->items))
        {
            
$ret[$baseurl] = $baseurl;
            return 
$ret;
        }
    }

    // Fetch the page
    //$g = $tornevall->www->get($url);
    
$g rss_getcontent($baseurl);

    // Not used anymore, but available!
    //$g = preg_replace("[\"index]", '"' . $baseurl . '/index', $g);    // Base for blogg.se

    // dots isn't a survivor in this case, we need to use something that is
    // definetively not conflicting in urls
    $g preg_replace("[\.]"chr(0), $g);    // ... so replace all dots with a null-char
    
$data preg_split("/[\"(.*)\"]/si"$g);

    // Linkscan: Check if there's a known feedlink in the url-list
    
foreach ($data as $delims => $content)
    {
        unset(
$matchfeed);
        foreach (
$feedcontent as $feedtest) {if (preg_match("/$feedtest/is"$content)) {$matchfeed true;}}
        if (
$matchfeed)
        {
            
$possiblefeed true;
            
$feedlist[$content] = $content;
        }
    }
    
// If we have positive matches from the feedscanner, replace the url-list with a smaller one!
    
if ($possiblefeed) {$data $feedlist;}

    // Collect strings beginning with http*
    
foreach ($data as $delims => $content)
    {
        
// preg_replace and chr(0) does not like each other,
        // so implode an exploder to restore the value...
        
$fixurl preg_replace("[/$]"''implode("."explode(chr(0), $content)));
        unset(
$isext);
        foreach (
$ignore as $exts) {if (preg_match("/".$exts."\$/i"$fixurl)) {$isext true;}}
        if (!
$isext && $fixurl)
        {
            if (!
preg_match("/^http/i"$fixurl)) {$fixurl $baseurl "/" $fixurl;}
            
$domcheck explode("/"$fixurl);
            
//$r = long2ip(ip2long($tornevall->resolve($domcheck[2])));
            
$r long2ip(ip2long(gethostbyname($domcheck[2])));
            
// Only valid urls allowed
            
if ($r != "0.0.0.0")
            {
                
$urls[$fixurl] = $fixurl;
            }
        }
    }

    // Loop through our list and see if some of them contains something
    
foreach ($urls as $url)
    {
        if (
$showaction)
        {
            if (
$showaction == 1) {echo ".";}
            if (
$showaction == 2) {echo "GET $url\n";}
        }
        
//$testxml = $tornevall->www->get($url);
        
$testxml rss_getcontent($url);

        // Try to find rss-content, but only if the linkname does not contain comments...
        
if ((preg_match("/xml version/i"$testxml) || preg_match("/rss version/i"$testxml)) && !preg_match("/comment/i"$url))
        {
            if (
$showaction)
            {
                if (
$showaction == 1) {echo "?";}
                if (
$showaction == 2) {echo "Found valid content, trying to convert...\n";}

            }
            $rssdata = @fetch_rss($url);
            if (
sizeof($rssdata->items) > 1)
            {
                if (
$showaction)
                {
                    if (
$showaction == 1) {echo "!";}
                    if (
$showaction == 2) {echo "ITEMS: ".sizeof($rssdata->items)."\n";}
                }
                
$rsslink[$url] = $url;
                if (
$breakonfirst) {break;}
            }
        }
    }
    if (
$showaction)
    {
        if (
$showaction == 1) {echo "F\n";}
        if (
$showaction == 2) {echo "FINISH\n";}
    }

    if (sizeof($rsslink)) {return($rsslink);}
}

/* Instead of file_get_contents */
function rss_getcontent($URL '')
{
    
$c curl_init($URL);

    // Short timeouts is good, but it's risky since you may suffer dataloss
    
$timeout 30;
    
$headers[] = 'Accept: image/gif, image/x-bitmap, image/jpeg, image/pjpeg';
    
$headers[] = 'Connection: Keep-Alive';
    
$headers[] = 'Content-type: application/x-www-form-urlencoded;charset=UTF-8';
    
$user_agent 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; .NET CLR 1.0.3705; .NET CLR 1.1.4322; Media Center PC 4.0)';
    
curl_setopt($cCURLOPT_TIMEOUT,$timeout); 
    
curl_setopt($cCURLOPT_VERBOSE,false);
    
curl_setopt($cCURLOPT_HTTPHEADER$headers);
    
curl_setopt($cCURLOPT_USERAGENT$user_agent);
    
curl_setopt($cCURLOPT_RETURNTRANSFER1);
    
curl_setopt($cCURLOPT_FOLLOWLOCATION1);
    
curl_setopt($cCURLOPT_RETURNTRANSFER1);
    
$contents curl_exec($c);
    
curl_close($c);

    if ($contents)
    {
        return 
$contents;
    }
    else
    {
        return 
FALSE;
    }
}

?>


I’ve read a bit about people that wants to find out if a columnvalue in a DB2-table contains numerics only. I’ve also read solutions that’s is more advanced than it have to be. So the solution I found, is the following… Can it be easier?

LENGTH(REPLACE(TRANSLATE(COLUMN_NAME, ' ', '0123456789'), ' ', '')) = 0

It’s all about removing all numerics in the search, so the column only returns non-numerics. Then count the characters that were left alone. If the length of the output is zero, we know that the column contains nothing after the clearout. If that’s the case, we’ve found a numeric-only value.

FireStats icon Använder FireStats