cea-sec/miasm

View on GitHub

Showing 3,020 of 3,020 total issues

Identical blocks of code found in 7 locations. Consider refactoring.
Open

                addr, size = (int(x, 16) for x in buf.read().split(b",", 1))
Severity: Major
Found in miasm/analysis/gdbserver.py and 6 other locations - About 30 mins to fix
miasm/analysis/gdbserver.py on lines 158..158
miasm/analysis/gdbserver.py on lines 168..168
miasm/analysis/gdbserver.py on lines 183..183
miasm/analysis/gdbserver.py on lines 202..202
miasm/analysis/gdbserver.py on lines 214..214
miasm/analysis/gdbserver.py on lines 227..227

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 16 locations. Consider refactoring.
Open

def msvcrt_atexit(jitter):
    ret_ad, _ = jitter.func_args_cdecl(["func"])
    jitter.func_ret_cdecl(ret_ad, 0)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
miasm/os_dep/linux_stdlib.py on lines 197..199
miasm/os_dep/win_api_x86_32.py on lines 293..295
miasm/os_dep/win_api_x86_32.py on lines 310..312
miasm/os_dep/win_api_x86_32.py on lines 316..318
miasm/os_dep/win_api_x86_32.py on lines 412..414
miasm/os_dep/win_api_x86_32.py on lines 422..424
miasm/os_dep/win_api_x86_32.py on lines 473..475
miasm/os_dep/win_api_x86_32.py on lines 478..480
miasm/os_dep/win_api_x86_32.py on lines 590..592
miasm/os_dep/win_api_x86_32.py on lines 1348..1350
miasm/os_dep/win_api_x86_32.py on lines 1994..1998
miasm/os_dep/win_api_x86_32.py on lines 2429..2431
miasm/os_dep/win_api_x86_32.py on lines 2556..2558
miasm/os_dep/win_api_x86_32.py on lines 2806..2808
miasm/os_dep/win_api_x86_32.py on lines 2936..2938

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Avoid too many return statements within this function.
Open

                return False
Severity: Major
Found in miasm/core/graph.py - About 30 mins to fix

    Similar blocks of code found in 16 locations. Consider refactoring.
    Open

    def kernel32_LocalFree(jitter):
        ret_ad, _ = jitter.func_args_stdcall(["lpvoid"])
        jitter.func_ret_stdcall(ret_ad, 0)
    Severity: Major
    Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
    miasm/os_dep/linux_stdlib.py on lines 197..199
    miasm/os_dep/win_api_x86_32.py on lines 310..312
    miasm/os_dep/win_api_x86_32.py on lines 316..318
    miasm/os_dep/win_api_x86_32.py on lines 412..414
    miasm/os_dep/win_api_x86_32.py on lines 422..424
    miasm/os_dep/win_api_x86_32.py on lines 473..475
    miasm/os_dep/win_api_x86_32.py on lines 478..480
    miasm/os_dep/win_api_x86_32.py on lines 590..592
    miasm/os_dep/win_api_x86_32.py on lines 1348..1350
    miasm/os_dep/win_api_x86_32.py on lines 1994..1998
    miasm/os_dep/win_api_x86_32.py on lines 2429..2431
    miasm/os_dep/win_api_x86_32.py on lines 2556..2558
    miasm/os_dep/win_api_x86_32.py on lines 2806..2808
    miasm/os_dep/win_api_x86_32.py on lines 2936..2938
    miasm/os_dep/win_api_x86_32.py on lines 3006..3008

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 16 locations. Consider refactoring.
    Open

    def kernel32_CloseHandle(jitter):
        ret_ad, _ = jitter.func_args_stdcall(["hwnd"])
        jitter.func_ret_stdcall(ret_ad, 1)
    Severity: Major
    Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
    miasm/os_dep/linux_stdlib.py on lines 197..199
    miasm/os_dep/win_api_x86_32.py on lines 293..295
    miasm/os_dep/win_api_x86_32.py on lines 310..312
    miasm/os_dep/win_api_x86_32.py on lines 316..318
    miasm/os_dep/win_api_x86_32.py on lines 412..414
    miasm/os_dep/win_api_x86_32.py on lines 473..475
    miasm/os_dep/win_api_x86_32.py on lines 478..480
    miasm/os_dep/win_api_x86_32.py on lines 590..592
    miasm/os_dep/win_api_x86_32.py on lines 1348..1350
    miasm/os_dep/win_api_x86_32.py on lines 1994..1998
    miasm/os_dep/win_api_x86_32.py on lines 2429..2431
    miasm/os_dep/win_api_x86_32.py on lines 2556..2558
    miasm/os_dep/win_api_x86_32.py on lines 2806..2808
    miasm/os_dep/win_api_x86_32.py on lines 2936..2938
    miasm/os_dep/win_api_x86_32.py on lines 3006..3008

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 16 locations. Consider refactoring.
    Open

    def kernel32_TlsFree(jitter):
        ret_ad, _ = jitter.func_args_stdcall(["tlsindex"])
        jitter.func_ret_stdcall(ret_ad, 0)
    Severity: Major
    Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
    miasm/os_dep/linux_stdlib.py on lines 197..199
    miasm/os_dep/win_api_x86_32.py on lines 293..295
    miasm/os_dep/win_api_x86_32.py on lines 310..312
    miasm/os_dep/win_api_x86_32.py on lines 316..318
    miasm/os_dep/win_api_x86_32.py on lines 412..414
    miasm/os_dep/win_api_x86_32.py on lines 422..424
    miasm/os_dep/win_api_x86_32.py on lines 473..475
    miasm/os_dep/win_api_x86_32.py on lines 478..480
    miasm/os_dep/win_api_x86_32.py on lines 590..592
    miasm/os_dep/win_api_x86_32.py on lines 1348..1350
    miasm/os_dep/win_api_x86_32.py on lines 1994..1998
    miasm/os_dep/win_api_x86_32.py on lines 2556..2558
    miasm/os_dep/win_api_x86_32.py on lines 2806..2808
    miasm/os_dep/win_api_x86_32.py on lines 2936..2938
    miasm/os_dep/win_api_x86_32.py on lines 3006..3008

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 6 locations. Consider refactoring.
    Open

    def kernel32_GetLastError(jitter):
        ret_ad, _ = jitter.func_args_stdcall(0)
        jitter.func_ret_stdcall(ret_ad, winobjs.lastwin32error)
    Severity: Major
    Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
    miasm/os_dep/win_api_x86_32.py on lines 321..323
    miasm/os_dep/win_api_x86_32.py on lines 331..333
    miasm/os_dep/win_api_x86_32.py on lines 336..338
    miasm/os_dep/win_api_x86_32.py on lines 374..376
    miasm/os_dep/win_api_x86_32.py on lines 457..459

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    armtop("mul",  [bs('111110110000'), rn, bs('1111'), rd, bs('0000'), rm], [rd, rn, rm] )
    Severity: Major
    Found in miasm/arch/arm/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/arm/arch.py on lines 3369..3369
    miasm/arch/arm/arch.py on lines 3408..3408
    miasm/arch/arm/arch.py on lines 3409..3409

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

        e.append(m2_expr.ExprAssign(float_c1,
                                 m2_expr.ExprOp('fcom_c1', dst,
                                                src.zeroExtend(dst.size))))
    Severity: Major
    Found in miasm/arch/x86/sem.py and 3 other locations - About 30 mins to fix
    miasm/arch/x86/sem.py on lines 2258..2260
    miasm/arch/x86/sem.py on lines 2264..2266
    miasm/arch/x86/sem.py on lines 2267..2269

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

            offsettodata_o = struct.unpack('I', raw[off:off + 4])[0]
    Severity: Minor
    Found in miasm/loader/pe.py and 2 other locations - About 30 mins to fix
    miasm/loader/pe.py on lines 1133..1133
    miasm/loader/pe.py on lines 1540..1540

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    armtop("udiv", [bs('111110111011'), rn, bs('1111'), rd, bs('1111'), rm], [rd, rn, rm] )
    Severity: Major
    Found in miasm/arch/arm/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/arm/arch.py on lines 3369..3369
    miasm/arch/arm/arch.py on lines 3408..3408
    miasm/arch/arm/arch.py on lines 3412..3412

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

                elif arg.op == 'LSL' and int(arg.args[1]) == 0:
    Severity: Minor
    Found in miasm/arch/aarch64/arch.py and 1 other location - About 30 mins to fix
    miasm/arch/aarch64/arch.py on lines 425..425

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    armop("sxtb", [bs('01101010'), bs('1111'), rd, rot_rm, bs('00'), bs('0111'), rm_noarg])
    Severity: Major
    Found in miasm/arch/arm/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/arm/arch.py on lines 1825..1825
    miasm/arch/arm/arch.py on lines 1826..1826
    miasm/arch/arm/arch.py on lines 1828..1828

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    mips32op("mfc1",    [cpu.bs('010001'), cpu.bs('00000'), rt, fs,
                         cpu.bs('00000000000')])
    Severity: Major
    Found in miasm/arch/mips32/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/mips32/arch.py on lines 748..749
    miasm/arch/mips32/arch.py on lines 751..752
    miasm/arch/mips32/arch.py on lines 754..755

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    mips32op("cfc1",    [cpu.bs('010001'), cpu.bs('00010'), rt, fs,
                         cpu.bs('00000000000')])
    Severity: Major
    Found in miasm/arch/mips32/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/mips32/arch.py on lines 690..691
    miasm/arch/mips32/arch.py on lines 748..749
    miasm/arch/mips32/arch.py on lines 754..755

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

        e.append(m2_expr.ExprAssign(float_c2,
                                 m2_expr.ExprOp('fcom_c2', dst,
                                                src.zeroExtend(dst.size))))
    Severity: Major
    Found in miasm/arch/x86/sem.py and 3 other locations - About 30 mins to fix
    miasm/arch/x86/sem.py on lines 2258..2260
    miasm/arch/x86/sem.py on lines 2261..2263
    miasm/arch/x86/sem.py on lines 2267..2269

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 6 locations. Consider refactoring.
    Open

    def user32_GetForegroundWindow(jitter):
        ret_ad, _ = jitter.func_args_stdcall(0)
        jitter.func_ret_stdcall(ret_ad, winobjs.getforegroundwindow)
    Severity: Major
    Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
    miasm/os_dep/win_api_x86_32.py on lines 321..323
    miasm/os_dep/win_api_x86_32.py on lines 331..333
    miasm/os_dep/win_api_x86_32.py on lines 336..338
    miasm/os_dep/win_api_x86_32.py on lines 374..376
    miasm/os_dep/win_api_x86_32.py on lines 1002..1004

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

            self.my_args.append((ExprId("vmcpu", 32),
                                 llvm_ir.PointerType(LLVMType.IntType(8)),
                                 "vmcpu"))
    Severity: Major
    Found in miasm/jitter/llvmconvert.py and 3 other locations - About 30 mins to fix
    miasm/jitter/llvmconvert.py on lines 1708..1710
    miasm/jitter/llvmconvert.py on lines 1714..1716
    miasm/jitter/llvmconvert.py on lines 1717..1719

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

    mips32op("divu",    [cpu.bs('000000'), rs, rt, cpu.bs('0000000000'),
                         cpu.bs('011011')])
    Severity: Major
    Found in miasm/arch/mips32/arch.py and 3 other locations - About 30 mins to fix
    miasm/arch/mips32/arch.py on lines 682..683
    miasm/arch/mips32/arch.py on lines 703..704
    miasm/arch/mips32/arch.py on lines 705..706

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

            op, args = tokens[1], [tokens[0], tokens[2]]
    Severity: Minor
    Found in miasm/core/cpu.py and 1 other location - About 30 mins to fix
    miasm/core/cpu.py on lines 366..366

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 32.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Severity
    Category
    Status
    Source
    Language