Algorithmen, Teil IX.: Computer und andere Haustiere

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Info! Wir verlosen 3 x das Nacken- und Schultermassagegerät Optimus New Generation Jade! - Spiel mit!

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • Algorithmen, Teil IX.: Computer und andere Haustiere

      Abt. Algorithmen Teil IX. hiermit feierlich eröffnet:
      ================================< SCHNIPP >============================
      :thumbsup: Na dann mal los!
      Gruss

      P.S.: Zum Inhaltsverzeichnis vom vorigen Teil geht's HIER.

      Und hier jenes Youtube-Link, daß Anlaß für das obige Motto war :idea:.

      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Frabbing ()

    • Abt. Sekundentimer
      =============
      Beim proggen eines Weckers gibt es mehrere Lösungen, um Ziffernwechsel (mindestens in der Sekundenanzeige) auszulösen. Nicht gerade ressourcenschonend ist es, ständig hochfrequent date$(3),time$(0) und den Sekundenteil (Vorkommateil) von time$(1) abzufragen. Weiteres Problem: Irgendwann gehen die Nachkommastellen von time$(1) über .999 hinaus - und das bedeutet, daß eine ganze Sekundenziffer übersprungen wird. Das sieht dann eigenartig aus: 30, 31,32,34,35,36...

      Ressourcenschonender scheint es, die Systemzeitfunktionen genau jede Sekunde einmal abzufragen. Leider ist der XProfan-Timer etwas belastungsabhängig, und "Waitinput 1000" wartet daher oft etwas länger als 1000 ms. "Waitinput 990" flutscht ein andermal wieder zu schnell durch, die Wahrheit liegt also irgendwo in der Mitte bzw. :!: ein Korrektursummand könnte vom Nachkommateil abhängig gemacht werden (Phase Locked Loop-Prinzip, PLL). Es handelt sich um einen P-Regler (''P wie Proportional'), der allerdings etwas schwierig einzustellen ist. Bei Normallast klappt bei mir jedenfalls nachstehendes recht gut.
      Gruss

      P.S.: Selbstverständlich machen Profis das über Callback-Events, - mir ging es hier um eine reine Profan-Lösung...

      Quellcode

      1. CLS
      2. Repeat
      3. waitinput 990-0.006*(val(right$("000"+substr$(time$(1),2,"."),3))-500)
      4. print left$(right$(date$(5),26),20)+"."+right$("000"+substr$(time$(1),2,"."),3)
      5. until 0
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Abt. Spiralo - rekursiv
      ==============
      Naja, wieder mal ein Bildschirmschoner. Gähn...
      Gruss

      Quellcode

      1. Windowtitle "SPIRALO - Ein rekursiver Spiralalgorithmus"
      2. Windowstyle 24:Window 0,0-%maxx,%maxy:randomize
      3. Declare xh&,yh&,x!,y!,xn!,yn!,r!,s!,co&
      4. Repeat:r!=width(%hwnd):s!=pi()/180
      5. xh&=rnd(width(%hwnd)):yh&=rnd(height(%hwnd))
      6. x!=r!:moveto xh&+x!,yh&:co&=rnd(8^8):usepen 0,10,co&
      7. go
      8. until %key=27:end
      9. proc go
      10. if r!>4:s!=s!+sqrt(s!)*0.004:usepen 0,20-38*s!,co&
      11. xn!=x!*cos(s!)+y!*sin(s!):yn!=y!*cos(s!)-x!*sin(s!)
      12. xn!=xn!*0.985:yn!=yn!*0.985:r!=r!*0.985
      13. 'locate 1,1:print r!,xn!,yn!
      14. line xh&+x!,(yh&-y!) - xh&+xn!,(yh&-yn!)
      15. x!=xn!:y!=yn!
      16. if rnd(100)<20:waitinput 1:case %key>0:END:endif
      17. go 'REKURSION!
      18. endif
      19. endproc
      Alles anzeigen
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Ist meines Erachtens der selbe Timer, halt nur als One-Shot angesprochen (also immer automatisch mit implizitem Killtimer-Befehl). Indiz: Die hohe Frequenz des Print-Befehls mit Ausgabe von '1' im folgenden Test, weil der selbe Timer neu gesetzt wird.
      Gruss

      Quellcode

      1. cls
      2. declare ts%
      3. loop:
      4. SetTimer 1000
      5. WaitInput 200
      6. ts%=%wmTimer
      7. if ts%
      8. print ts%
      9. ts%=0
      10. KillTimer
      11. else
      12. print ts%
      13. endif
      14. goto "loop"
      Alles anzeigen
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Abt. Multi-Werterückgabe aus Procs
      ======================
      klappt ähnlich wie in Fortran-90 über die Parameterliste, in XProfan allerdings nur bei Arrayvariablen.
      Aufschlussreich war folgender Test:

      Quellcode

      1. cls
      2. declare a$[0]
      3. a$[0]="Test"
      4. op a$[],a$[],a$[]
      5. print a$[0]
      6. waitinput
      7. end
      8. proc op :parameters b$[],c$[],d$[]
      9. b$[0]="Overruled1"
      10. c$[0]="Overruled2"
      11. d$[0]="Overruled3"
      12. endproc
      Alles anzeigen

      Gruss
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • :whistling: Na ja, XProfan hat auch schon immer die Bereiche als byRef übergeben.

      Und das Ergebnis verwundert ja auch nicht...

      Quellcode

      1. cls
      2. declare a$[0],aa#
      3. dim aa#,200
      4. a$[0]="Test"
      5. string aa#,0 = "999999999999999"
      6. op a$[],a$[],a$[],aa#,aa#,aa#
      7. print a$[0],"-",string$(aa#,0)
      8. print "$: "; : whileloop 0,16 : print hex$(byte(aa#,&loop));" "; : endwhile
      9. dispose aa#
      10. waitinput
      11. end
      12. proc op :parameters b$[],c$[],d$[],bb#,cc#,dd#
      13. b$[0]="Overruled1"
      14. c$[0]="Overruled2"
      15. d$[0]="Overruled3"
      16. string bb#,0 = "11111111111"
      17. string cc#,0 = "22222222"
      18. string dd#,0 = "333"
      19. endproc
      Alles anzeigen


      Es war ja auch so geplant, das Strukturvariablen in UPROs bestückt werden können.

      Uns wird bei einfachen Variablen nur die byVal-Übergabe gegönnt, während Roland
      auch mal byRef übergibt.
      - oGL("2D", x,y,z, SX,SY )
      - Inc X
      - Dec X
      - ...und irgendwas uraltes, wo auch Koordinaten zurück gegeben werden...
      Programmieren, das spannendste Detektivspiel der Welt.
    • Abt. Namenlose Proc
      =============
      XProfan war schon immer gut für Überraschungen. Das z.B. klappt:

      Quellcode

      1. cls
      2. ""
      3. waitinput
      4. end
      5. proc ""
      6. print "\n Namenlose Proc erfolgreich aufgerufen! "
      7. endproc

      Aber auch das:

      Quellcode

      1. cls
      2. gosub """"
      3. waitinput
      4. end
      5. "":
      6. print "\n Namenloses UPro erfolgreich aufgerufen! "
      7. return

      und sogar das hier:

      Quellcode

      1. cls
      2. var a$=""""
      3. gosub a$
      4. waitinput
      5. end
      6. "":
      7. print " Code erfolgreich aufgerufen! "
      8. return

      und im Interpreter:

      Quellcode

      1. cls
      2. var a$=""""
      3. execute a$
      4. waitinput
      5. end
      6. proc ""
      7. print "Namenlose Proc erfolgreich aufgerufen"
      8. endproc


      Endgültig haut einen dann folgendes aus den Socken:

      Quellcode

      1. cls
      2. var a$=chr$(34)
      3. execute a$
      4. waitinput
      5. end
      6. proc "
      7. print "Namenlose Proc erfolgreich aufgerufen"
      8. endproc

      bzw. noch erstaunlicher:

      Quellcode

      1. cls
      2. "
      3. waitinput
      4. end
      5. proc "
      6. print "Namenlose Proc erfolgreich aufgerufen"
      7. endproc

      Gruss

      P.S.: Fasching (Karnevalszeit) kommt ja bald...
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Abt. Anzahl Tage zwischen zwei Datumsangaben
      ==============================
      Ähm... gabs auch schon mal, aber ich nähere mich altersmäßig gerade wieder einmal einer 1000-Tage-Marke, und wollte dazu den genauen Tag ermitteltn. Mit etwas raten gelingt das...
      Gruss

      Quellcode

      1. Windowtitle upper$(" Anzahl der Tage zwischen zwei Datumsangaben"):font 2:randomize:clrs
      2. Appendmenubar 100,"Achtung: Gilt nur im Zeiraum 1.01.1901 bis 31.12.2099 !"
      3. Declare a!,a$,y&,m&,d&,n!,r!,A![12]:A![1]=0:A![2]=31:A![3]=59.25:A![4]=90.25:A![5]=120.25
      4. A![6]=151.25:A![7]=181.25:A![8]=212.25:A![9]=243.25:A![10]=273.25:A![11]=304.25:A![12]=334.25
      5. NEU:
      6. PRINT "\n Bitte das Bezugsdatum eingeben: (Enter für "heute")\n"
      7. clear m&,d&,y&,n!,r!:Eingab :R!=N!:nochmal:
      8. PRINT "\n Abfragedatum eingeben:\n":Eingab
      9. A!=N!-R!:PRINT "\n Anzahl der dazwischen liegenden Tage: ";int(abs(A!))
      10. if %csrlin>24:waitinput:clrs:endif
      11. if int(A!)=0:Print "\n Wird ein neues Bezugsdatum gewünscht [j/n]? ";:input a$
      12. a$=trim$(a$):a$=lower$(a$):a$=left$(a$,1):if (a$="j") or (a$="y") or (a$="1")
      13. clrs:goto "NEU":endif
      14. endif:goto "nochmal"
      15. proc Eingab
      16. Print " Jahr (4-stellig): ";:input y&
      17. if y&=0:y&=val(left$(date$(3),4)):m&=val(mid$(date$(3),5,2))
      18. d&=val(right$(date$(3),2)):print " ";y&,m&,d&;"\n"
      19. else
      20. mon:
      21. Print " Monat (2stellig): ";:input m&
      22. case (m&<1) or (m&>12):goto "mon"
      23. day:
      24. Print " Tag (2-stellig): ";:input d&
      25. case (d&<1) or (d&>31):goto "day"
      26. endif
      27. N!=365.25*(Y&-1901)+A![M&]+D&:N!=int(N!)
      28. endproc
      29. proc clrs :CLS rgb(200+rnd(56),200+rnd(56),200+rnd(56))
      30. endproc
      Alles anzeigen
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Liebe Leute, ich muss mich für die nächste Zeit hier ausklinken, es wartet eine :hz: -OP auf mich. In einigen Wochen wissen wir, ob's geklappt hat. Melde mich, sobald wieder fit. Gruss, und führt die Kolumne im begonnenen Geist weiter!
      LG, euer
      P. Specht
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Von mir auch die besten Wünsche für die OP!.

      Ich weiß nicht, ob es im Sinne dieses Threads ist aber obiges Codeungetüm lässt sich in der aktuellen Version in wenigen zeilen abhandeln:

      Quellcode

      1. Proc DeltaTage
      2. Parameters Datum1$,Datum2$
      3. 'Datum im Format dd.mm.jjjj
      4. 'hier könnte man durch Parameterüberprüfung mehrere Formate erlauben.
      5. Declare d1!,d2!
      6. d1! = dt("setDate", Datum1$)
      7. d2! = dt("setDate", Datum2$)
      8. Return dt("DaysBetween", d1!,d2!)
      9. EndProc
      10. print DeltaTage("02.02.2015","02.02.2016")
      11. WaitInput
      Alles anzeigen
      Anhören lohnt sich wuestensand.info
    • Danke für die guten Wünsche, haben geholfen: Melde mich hiermit offiziell mit ein paar neuen Henkeln am Herz zurück!
      (Etwas knieweich, und nach 10 Minuten Quatschen oder tippen geht mir derzeit die Luft aus, aber das wird schon wieder)
      Gruss
      P. Specht
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Prozesspfad ohne Rechte auf den Prozess ermitteln

      Ab Vista:
      Prozesspfad komplett ohne Rechte auf die Prozesse auslesen. Funktioniert ab Vista - selbst als normaler Benutzer. Liest ohne Aktivierung von Privilegien auch Pfade von Protected Processes aus.

      Quellcode

      1. '#############################################################################################
      2. '################### ProzessPfad ohne Rechte auf Prozess ermitteln #######################
      3. '################### Quelltext erstellt von AHT #######################
      4. '################### für http://www.paules-pc-forum.de #######################
      5. '################### Funktioniert ab Systemen ab Vista #######################
      6. '#############################################################################################
      7. Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot"
      8. Def Process32First(2) !"Kernel32", "Process32First"
      9. Def Process32Next(2) !"Kernel32", "Process32Next"
      10. Def CloseHandle(1) !"Kernel32", "CloseHandle"
      11. Def NtQuerySystemInformation(4) !"NTDLL", "NtQuerySystemInformation"
      12. DEF WideCharToMultiByte(8) !"kernel32", "WideCharToMultiByte"
      13. Def QueryDosDevice(3) !"Kernel32", "QueryDosDeviceA"
      14. Declare Entry#, err&, handle&, cpid&, text$, text2$, PHandle&, Filename#
      15. declare UNICODE_STRING#, processIdInfo#, uBuffer#, aBuffer#
      16. Declare RootDir#, RootDir_Object#
      17. Declare ProcessPath$
      18. Struct PROCESSENTRY32=dwSize&, \
      19. cntUsage&, \
      20. th32ProcessID&, \
      21. th32DefaultHeapID&, \
      22. th32ModuleID&, \
      23. Threads&, \
      24. th32ParentProcessID&, \
      25. pcPriClassBase&, \
      26. dwFlags&, \
      27. szExeFile$(260)
      28. Dim Entry#,PROCESSENTRY32
      29. Entry#.dwSize& = SizeOf(Entry#)
      30. Proc HoleProzesse
      31. handle& = CreateToolhelp32Snapshot(2,0)
      32. If handle&
      33. err& = Process32First(handle&, Entry#)
      34. If err&
      35. text$ = Str$(Entry#.th32ProcessID&)
      36. text2$ = Entry#.szExeFile$
      37. ADDSTRING "PID: " + text$ + " | Prozessname: " + text2$ + " | Prozesspfad: " + GetProcessImageFileName(Entry#.th32ProcessID&)
      38. Repeat
      39. err& = Process32Next(handle&, Entry#)
      40. If err&
      41. text$ = Str$(Entry#.th32ProcessID&)
      42. text2$ = Entry#.szExeFile$
      43. ADDSTRING "PID: " + text$ + " | Prozessname: " + text2$ + " | Prozesspfad: " + GetProcessImageFileName(Entry#.th32ProcessID&)
      44. EndIf
      45. Until err& = 0
      46. CloseHandle(handle&)
      47. EndIf
      48. EndIf
      49. EndProc
      50. Proc GetProcessPath2
      51. Parameters Objekt_Pfad$
      52. Declare Richtiger_Prozesspfad$, Ende%
      53. Declare Objektname_Verzeichnis$
      54. Clear Richtiger_Prozesspfad$
      55. Dim RootDir#,3
      56. DIM RootDir_Object#, 2004
      57. String RootDir#, 0 = "A:"
      58. Whileloop 26
      59. External("kernel32", "QueryDosDeviceA", RootDir#, RootDir_Object#, 2000)
      60. IF instr(Upper$(String$(RootDir_Object#, 0)), Upper$(Objekt_Pfad$)) = 1
      61. Objektname_Verzeichnis$ = Left$(Objekt_Pfad$, len(String$(RootDir_Object#, 0)))
      62. Richtiger_Prozesspfad$ = Translate$(Objekt_Pfad$, Objektname_Verzeichnis$, String$(RootDir#, 0))
      63. IF FileExists(Richtiger_Prozesspfad$)
      64. ENDE%=1
      65. endif
      66. endif
      67. Case Ende%=1 : Break
      68. Byte RootDir#,0=Byte(RootDir#,0)+1 'Nächstes Laufwerk holen
      69. wend
      70. Dispose RootDir#
      71. Dispose RootDir_Object#
      72. ProcessPath$ = Richtiger_Prozesspfad$
      73. Return ProcessPath$
      74. endproc
      75. Proc GetProcessImageFileName
      76. parameters PID&
      77. Declare retlength&, Status%, Fehler%
      78. Dim UNICODE_STRING#, 8
      79. Dim processIdInfo#, 12
      80. Dim uBuffer#, 1400
      81. LONG processIdInfo#, 0 = PID&
      82. Word processIdInfo#, 4 = 0
      83. Word processIdInfo#, 6 = 700
      84. LONG processIdInfo#, 8 = uBuffer#
      85. clear uBuffer#, ProcessPath$
      86. Status% = NtQuerySystemInformation(88, processIdInfo#, SizeOf(processIdInfo#), addr(retlength&))
      87. If Status% = 0
      88. DIM aBuffer#, 700
      89. Fehler% = WideCharToMultiByte(0, 0, uBuffer#, word(processIdInfo#, 4), aBuffer#, 600, 0, 0)
      90. If Fehler%
      91. GetProcessPath2(String$(aBuffer#, 0))
      92. endif
      93. Dispose aBuffer#
      94. endif
      95. Dispose uBuffer#
      96. Dispose processIdInfo#
      97. Dispose UNICODE_STRING#
      98. Return ProcessPath$
      99. EndProc
      100. 'Test
      101. ClearList
      102. HoleProzesse
      103. EditBox("Prozesse",1)
      Alles anzeigen
      ________________________________________________________

      PPFScanner PPFS Android MisterXMail@web.de
      Mfg AHT

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()

    • Das ist ja absolut unheimlich!!! ... Kann man überhaupt noch irgend einer größeren Softwarefirma heute vertrauen, wenn solche Möglichkeiten bestehen? Z.B. habe ich ein Firefox Update angeboten bekommen, das von Firefox letztlich gar nicht autorisiert war. Seither funktioniert kein Download mehr ausser von dieser Seite, von der das Update kam... Musste FF löschen und neu aufsetzen!
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • Die Sache ist von M$ so gewollt und wird mit Sicherheit auch in einer der nächsten Windowsversionen den Einzug in eine dokumentierte API erhalten. Wenn du dir die Entwicklung der Protected Processes bis Windows10 einmal ansiehst, wirst du feststellen, dass immer mehr Prozesse des Systems geschützt werden. Ein Auslesen von Prozesspfaden der Systemprozesse ist da selbst mit Adminrechten nicht mehr möglich - Privileg SeDebugPrivilege aktivieren und Prozesshandle mit speziellem Zugriffsrecht öffnen ist da schon Pflicht. Ohne das geht's nicht. Das ist die Abhilfe.
      ________________________________________________________

      PPFScanner PPFS Android MisterXMail@web.de
      Mfg AHT
    • Abt. Gibt es INFORMATIONSSICHERHEIT ?
      ===========================
      Ich vermute mal, daß die Profi-Lauscher von NSA & Co noch ganz andere Hintertürchen eingebaut (bzw. eingebaut bekommen) haben. Muss man heute wirklich zum Superspezialisten ("zum AHT") werden, um zu verstehen was da eigentlich abgeht? Ich meine, früher war die Computerwelt wirklich einfacher - nur daß wir DAUs den Punkt verpasst haben, ab dem wir mit unseren Daten viel viel vorsichtiger hätten umgehen müssen. Zwar gibt es (in D) z.B. das Bundesamt für Sicherheit in der Informationstechnik oder die Österreichische Datenschutzbehörde, aber wie sicher sind eigentlich deren Tipps - und wem dienen sie eigentlich wirklich? Ich sehe eine allgemeine Vertrauenskrise: "Je mehr Sicherheit ein System verspricht, umso Hintertürchen-behafteter wird es geliefert..."
      Gruss

      P.S.: Wir etwas einfach gestrickten Ösis wollen scheinbar immer noch dran glauben: Sicherheitshandbuch.pdf
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

    • p. specht schrieb:

      Muss man heute wirklich zum Superspezialisten ... werden, um zu verstehen was da eigentlich abgeht?

      Ich habe mich da vom Zitat da mal gestrichen - zu den "Superprofis" würde ich persönlich ganz andere Leute zählen und nicht mich.
      Die Computerwelt ist für Progger immer noch extrem einfach (besteht nur aus Einsen und Nullen - das meine ich jetzt wirklich ernst). Es gibt dabei aber zwei Probleme:
      1. Man muss erst mal verstehen, wie einfach Sachen sind. Wie einfach die sind, ist das eigentlich erschreckende an manchen Sachen. Als ich vor über den Daumen gepeilt mehr als 10 Jahren angefangen habe, mich programmiertechnisch mit dem Security Bereich zu beschäftigen, habe ich mir natürlich auch einiges an "Literatur" reingepfiffen. Das Zeug war alles ziemlich unverständlich. Die Sachen waren aber nicht unverständlich, weil sie schwer sind - im Gegenteil. Beschäftigt man sich wirklich "handwerklich" mit diesen Sachen, sind sie extrem einfach zu verstehen. Es ist nur schwer, etwas in wenigen Worten einfach auszudrücken. Der Computerbereich ist so umfangreich, dass man im Prinzip nicht alles Wissen kann und irgendwo meistens einfache Grundlagen fehlen, um Sachen dann wirklich bis ins Letzte zu verstehen. Zu verstehen sind die aber - und das auch für jeden.
        Desweiteren ist es leider auch oft so, dass die Leute, die etwas mittels Schriftstück weitergeben, dass was sie betrachten selbst gar nicht richtig verstanden haben. Was man liest, sollte man immer erst prüfen - oft stimmt das in der Art gar nicht. Selbst auf Microsoft Seiten ist das so. Die Leute, die manche Sachen aufschreiben, sind eben keine "Handwerker" - nur wer ein "Handwerker" in dem Bereich ist, von dem er schreibt, kann eine Sache vom Aufbau her begreifen und auch in ihrer simpelen Einfachheit verstehen.
      2. Bei den Sachen, mit denen man sich nicht direkt handwerklich beschäftigen kann, muss man an Informationen kommen. Das ist nicht ganz so einfach - denn wer Hintergrundinfos über das Betriebssystem besitzt, kann es auch aushebeln. Ein wirklich offener Austausch auf "handwerklicher" Basis erfolgt da nur im Bereich der Entwicklung von Malware - früher, als der Bereich noch öffentlich zugänglich war, waren es die RootKit-Entwickler, von denen man lernen konnte (verständlicher handwerklicher Level, auf dem da was ausgetauscht wurde), auch wenn man genau das Gegenteil davon geschrieben hat. Nach einigen Gesetzesänderungen (in Detschland 202c) hat man einige Zeit über gar nichts im Netz gefunden. Langsam nimmt das jetzt wieder zu (wenn es um unkritische Sachen wie die obrige geht). Man muss im Prinzip vorher aber schon wissen, wonach man sucht.

      Fazit: Die Computerwelt ist umfangreicher geworden, im Prinzip aber nicht schwieriger.

      p. specht schrieb:

      Ich meine, früher war die Computerwelt wirklich einfacher

      Es ist der Programmierbereich hier - wenn es um die Programmierung geht, dazu nur folgendes: Der war früher auch nicht einfacher, man musste sich nur lange Zeit um bestimmte Sachen gar nicht kümmern. Das sich das ändern wird, habe ich vor 15 Jahren schon irgendwo mal hingeschrieben.

      "Je mehr Sicherheit ein System verspricht, umso Hintertürchen-behafteter wird es geliefert..."

      Wenn du dir die augenblickliche Entwicklung im Malwarebereich so ansiehst, wirst du erkennen, dass dem nicht so ist. Es verlagert sich da zur Zeit scheinbar was, weil man mit bestimmten Sachen kein richtiges Geld mehr verdienen kann.
      Unter XP lag damals alles offen auf dem Tisch - jedes Kind konnte an Infos kommen, um das System komplett an allen möglichen Stellen auszuhebeln - dazu bedurfte es der NSA gar nicht. Gerade unter aktuellen 64Bit Systemen wird das immer schwieriger. Unter Windows10 wird da noch mehr dicht gemacht.
      Wende mal folgenden Code zum Listen von Prozessen unter XP, unter Windows7 und unter Windows10 (32Bit) an:

      Quellcode

      1. '#############################################################################################
      2. '###################### Quelltext erstellt von AHT ##############################
      3. '###################### für http://www.paules-pc-forum.de ##############################
      4. '#############################################################################################
      5. Def GetModuleFileNameEx(4) !"Psapi", "GetModuleFileNameExA"
      6. Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot"
      7. Def Process32First(2) !"Kernel32", "Process32First"
      8. Def Process32Next(2) !"Kernel32", "Process32Next"
      9. Def CloseHandle(1) !"Kernel32", "CloseHandle"
      10. Def GetCurrentProcessID(0) !"Kernel32", "GetCurrentProcessId"
      11. Def OpenProcess(3) !"Kernel32", "OpenProcess"
      12. DEF LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA"
      13. DEF AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges"
      14. DEF OpenProcessToken(3) !"advapi32","OpenProcessToken"
      15. DEF GetCurrentProcess(0) !"KERNEL32","GetCurrentProcess"
      16. DEF CopyMemory(3) !"kernel32","RtlMoveMemory"
      17. Declare Entry#, err&, handle&, cpid&, text$, text2$, PHandle&, Filename#
      18. Struct PROCESSENTRY32=dwSize&, \
      19. cntUsage&, \
      20. th32ProcessID&, \
      21. th32DefaultHeapID&, \
      22. th32ModuleID&, \
      23. Threads&, \
      24. th32ParentProcessID&, \
      25. pcPriClassBase&, \
      26. dwFlags&, \
      27. szExeFile$(260)
      28. Dim Entry#,PROCESSENTRY32
      29. Entry#.dwSize& = SizeOf(Entry#)
      30. Proc FillProcessList
      31. DIM Filename#, 514
      32. cpid& = GetCurrentProcessID()
      33. handle& = CreateToolhelp32Snapshot(2,0)
      34. If handle&
      35. err& = Process32First(handle&, Entry#)
      36. If err&
      37. text$ = Str$(Entry#.th32ProcessID&)
      38. text2$ = Entry#.szExeFile$
      39. Clear Filename#, PHandle&
      40. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
      41. IF PHandle& > 0
      42. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
      43. Closehandle(PHandle&)
      44. endif
      45. ADDSTRING "PID: " + text$ + " | Prozessname: " + text2$ + " | Prozesspfad: " + String$(Filename#,0)
      46. Repeat
      47. err& = Process32Next(handle&, Entry#)
      48. If err&
      49. text$ = Str$(Entry#.th32ProcessID&)
      50. text2$ = Entry#.szExeFile$
      51. Clear Filename#, PHandle&
      52. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
      53. IF PHandle& > 0
      54. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
      55. Closehandle(PHandle&)
      56. endif
      57. ADDSTRING "PID: " + text$ + " | Prozessname: " + text2$ + " | Prozesspfad: " + String$(Filename#,0)
      58. EndIf
      59. Until err& = 0
      60. CloseHandle(handle&)
      61. EndIf
      62. EndIf
      63. Dispose Filename#
      64. EndProc
      65. ClearList
      66. FillProcessList
      67. EditBox("Prozesse",1)
      Alles anzeigen

      Was fällt auf? Warum ist das so???
      Fazit: Auf den Systemen, die weniger Sicherheit versprechen, ist gar kein "Hintertürchen" nötig - jeder kann da durch die Haustür rein.
      ________________________________________________________

      PPFScanner PPFS Android MisterXMail@web.de
      Mfg AHT

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()